Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
−1
Я вот смотрю на Ричарда Столлмана... Вижу, как он всю жизнь рвёт на себе жопчик за халявное ПО...
И думаю: а что сделал ОН? Он написал "Photoshop"? Создал "Windows"? Разработал хоть что-то?
Знает ли он, что такое многочасовой, многодневный, многомесячный, а иногда и многолетний труд разработки?
Всё его достижение - это ТЕКСТ лицензии "GNU". Всё.
В чём смысл Ричарда Столлмана?И, кстати, нахуй вообще нужны лицензии на халявное ПО?
rotoeb,
30 Сентября 2020
0
Пиздец-оффтоп #6
#1: https://govnokod.ru/26503 https://govnokod.xyz/_26503
#2: https://govnokod.ru/26541 https://govnokod.xyz/_26541
#3: https://govnokod.ru/26583 https://govnokod.xyz/_26583
#4: https://govnokod.ru/26689 https://govnokod.xyz/_26689
#5: https://govnokod.ru/26784 https://govnokod.xyz/_26784
#5: https://govnokod.ru/26839 https://govnokod.xyz/_26839
nepeKamHblu_nemyx,
28 Сентября 2020
0
func verbMatches(p abac.Policy, a authorizer.Attributes) bool {
// TODO: match on verb
серёга, задолбал, давай уже в прод катить, потом свою авторизацию сделаешь
https://github.com/kubernetes/kubernetes/blob/master/pkg/auth/authorizer/abac/abac.go#L178
Fike,
28 Сентября 2020
+1
pub struct Vec { x: u32, y: u32, z: u32, }
pub extern "C" fn sum_c(a: &Vec, b: &Vec) -> Vec {
return Vec {x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
}
pub fn sum_rust(a: &Vec, b: &Vec) -> Vec {
return Vec {x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
}
Выхлоп:
example::sum_c:
mov eax, dword ptr [rsi]
add eax, dword ptr [rdi]
mov ecx, dword ptr [rsi + 4]
add ecx, dword ptr [rdi + 4]
mov edx, dword ptr [rsi + 8]
add edx, dword ptr [rdi + 8]
shl rcx, 32
or rax, rcx
ret
example::sum_rust:
mov ecx, dword ptr [rdx]
mov r8d, dword ptr [rdx + 4]
add ecx, dword ptr [rsi]
add r8d, dword ptr [rsi + 4]
mov edx, dword ptr [rdx + 8]
add edx, dword ptr [rsi + 8]
mov rax, rdi
mov dword ptr [rdi], ecx
mov dword ptr [rdi + 4], r8d
mov dword ptr [rdi + 8], edx
ret
«Дак йаже как Сишка!», «Даёшь пuтушатню в Ядро!»
https://godbolt.org/z/Tcnz75
rustc 1.46 (latest)
3.14159265,
28 Сентября 2020
0
#include <cstdlib>
#include <chrono>
#include <iostream>
#include <thread>
int p = 0;
int *q = nullptr;
void g()
{
using namespace std::chrono_literals;
std::cout << "g()" << std::endl;
std::cout << "g(): p = 1" << std::endl;
p = 1;
std::this_thread::sleep_for(1s);
if (q != nullptr) {
std::cout << "g(): *q = 1" << std::endl;
*q = 1;
} else {
std::cout << "g(): q == nullptr" << std::endl;
}
}
void f()
{
using namespace std::chrono_literals;
std::cout << "f()" << std::endl;
if (p == 0) {
std::cout << "f(): first loop start" << std::endl;
while (p == 0) { } // Потенциально конечный
std::cout << "f(): first loop end" << std::endl;
}
int i = 0;
q = &i;
std::cout << "f(): second loop start" << std::endl;
while (i == 0) { } // Потенциально конечный, хотя в условии только автоматическая пельменная
std::cout << "f(): second loop end" << std::endl;
}
int main()
{
using namespace std::chrono_literals;
std::cout << "f() thread start" << std::endl;
auto thr1 = std::thread(f);
thr1.detach();
std::this_thread::sleep_for(1s);
std::cout << "g() thread start" << std::endl;
auto thr2 = std::thread(g);
thr2.detach();
std::this_thread::sleep_for(2s);
std::cout << "Done" << std::endl;
std::_Exit(EXIT_SUCCESS);
}
Ожидание:
f() thread start
f()
f(): first loop start
g() thread start
g()
g(): p = 1
f(): first loop end
f(): second loop start
g(): *q = 1
f(): second loop end
Done
gost,
28 Сентября 2020
+2
/* https://habr.com/ru/company/piter/blog/491996/
Пусть в Python такая штука и называется генератором, в языке C++ она
называлась бы корутиной. Пример взят с этого сайта: https://masnun.com/2015/11/13/python-generators-coroutines-native-coroutines-and-async-await.html
def generate_nums():
num = 0
while True:
yield num
num = num + 1
nums = generate_nums()
for x in nums:
print(x)
if x > 9:
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#define START 0
#define YIELD 1
typedef struct
{
uint8_t jmpto;
int num;
} coroutine_state;
int generate_nums(coroutine_state *state)
{
switch(state->jmpto)
{
case START: break;
case YIELD: goto yield;
}
while (true)
{
state->jmpto = YIELD; return state->num; yield: // какая питушня
state->num = state->num + 1;
}
}
int main(void)
{
int x;
coroutine_state st = {START, 0};
while(true)
{
x = generate_nums(&st);
printf("%d\n", x);
if (x > 9)
{
break;
}
}
return EXIT_SUCCESS;
}
Попробовал переписать эту ко-ко-корутину c питуха на Си - получилась какая-то херня нечитаемая. что еще раз доказывает, что корутины нахуй не нужны
К тому же в крестопарашном говне они требуют хип, а это нахуй не нужно на самом-то деле.
j123123,
28 Сентября 2020
+2
Function/method calling convention. Here’s a simple example:
struct Foo { a: i32 }
impl Foo { fn bar(&mut self, val: i32) { self.a = val + 42; } }
fn main() {
let mut foo = Foo { a: 0 };
foo.bar(foo.a);
}
For now this won’t compile because of the borrowing but shouldn’t the compiler be smart enough to create a copy of foo.a before call?
I’m not sure but IIRC current implementation first mutably borrows object for the call and only then tries to borrow the arguments.
Is it really so and if yes, why?
Update: I’m told that newer versions of the compiler handle it just fine but the question still stands (was it just a compiler problem or the call definition has been changed?).
The other thing is the old C caveat of function arguments evaluation. Here’s a simple example:
let mut iter = “abc”.chars();
foo(iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap());
So would it be foo('a','b','c') or foo('c','b','a') call. In C it’s undefined because it depends on how arguments are passed on the current platform
(consider yourself lucky if you don’t remember __pascal or __stdcall).
In Rust it’s undefined because there’s no formal specification to tell you even that much.
And it would be even worse if you consider that you may use the same source for indexing the caller object like
handler[iter.next().unwrap() as usize].process(iter.next().unwrap()); in some theoretical bytecode handler
(of course it’s a horrible way to write code and you should use named temporary variables but it should illustrate the problem).https://codecs.multimedia.cx/2020/09/why-rust-is-not-a-mature-programming-language/
3.14159265,
27 Сентября 2020
0
IT Оффтоп #61
#33: https://govnokod.ru/26449 https://govnokod.xyz/_26449
#34: https://govnokod.ru/26456 https://govnokod.xyz/_26456
#35: https://govnokod.ru/26463 https://govnokod.xyz/_26463
#36: https://govnokod.ru/26508 https://govnokod.xyz/_26508
#37: https://govnokod.ru/26524 https://govnokod.xyz/_26524
#38: https://govnokod.ru/26539 https://govnokod.xyz/_26539
#39: https://govnokod.ru/26556 https://govnokod.xyz/_26556
#40: https://govnokod.ru/26568 https://govnokod.xyz/_26568
#41: https://govnokod.ru/26589 https://govnokod.xyz/_26589
#42: https://govnokod.ru/26600 https://govnokod.xyz/_26600
#43: https://govnokod.ru/26604 https://govnokod.xyz/_26604
#44: https://govnokod.ru/26627 https://govnokod.xyz/_26627
#45: https://govnokod.ru/26635 https://govnokod.xyz/_26635
#46: (vanished) https://govnokod.xyz/_26646
#46: (vanished) https://govnokod.xyz/_26654
#47: https://govnokod.ru/26671 https://govnokod.xyz/_26671
#48: https://govnokod.ru/26707 https://govnokod.xyz/_26707
#49: https://govnokod.ru/26750 https://govnokod.xyz/_26750
#49: https://govnokod.ru/26776 https://govnokod.xyz/_26776
#50: https://govnokod.ru/26804 https://govnokod.xyz/_26804
#51: https://govnokod.ru/26809 https://govnokod.xyz/_26809
#52: https://govnokod.ru/26817 https://govnokod.xyz/_26817
#53: https://govnokod.ru/26833 https://govnokod.xyz/_26833
#54: https://govnokod.ru/26840 https://govnokod.xyz/_26840
#55: https://govnokod.ru/26844 https://govnokod.xyz/_26844
#56: https://govnokod.ru/26862 https://govnokod.xyz/_26862
#57: https://govnokod.ru/26890 https://govnokod.xyz/_26890
#58: https://govnokod.ru/26916 https://govnokod.xyz/_26916
#59: https://govnokod.ru/26934 https://govnokod.xyz/_26934
#60: https://govnokod.ru/26949 https://govnokod.xyz/_26949
nepeKamHblu_nemyx,
25 Сентября 2020
0
Зачем в базах данных нужны несколько вариаций одного и того же типа?
Например, "tinyint", "mediumint", "smallint" и "bigint". Зачем они нужны, если
можно было бы просто сделать один "int", причём равнозначный нынешнему
"bigint"? Что даёт этот искусственно раздутый выбор целочисленных типов?
rotoeb,
25 Сентября 2020
−1
https://foren.germany.ru/elecronics/f/20343575.html
Математики из раш-ки изобрели бесконечные ноутбуки:
«Если магазин предоставляет опцию возврата, если товар не понравился, то почему мне должно быть стыдно?
Наоборот приятно - попользовался 3мя разными ноутами в течение месяца, не заплатив ни цента. Если бы им не нравилось это - они такую опцию не ввели бы, т.к. закон не обязывает.
Я гляжу, на форуме тут мало кто знает о бесплатном 14-дневном прокате техники в Сатурне. :)»
oaoaoammm,
25 Сентября 2020
Follow us!