677 karma · joined April 2, 2019
Qutebrowser is especially great for browsing documentation while coding. Besides it's main point of being keyboard driven, the lack of plugins makes it also absolutely distraction free.
> I had been harboring some suspicions that our big codebases might benefit from the application of some more of the various �modern� C++ design patterns, despite seeing other large game codebases suffer under them. I have since recanted that suspicion.
I think this shows that C++ works better in controlled (i.e. corporate environments), whereas C is often preferred in Open Source.
1 > {} // false
1 < {} // false
So the result of sorting will be random.People are fast to complain..
It has downsides though:
* Instead you have to use async/await throughout your code and suddenly have two execution models that you need to reason about
* Dropping the future won't help if the call is hanging on a blocking call either
* The callee doesn't know anything about a possible deadline
* You can only handle the cancellation in the callee in `Drop`, which gets complicated quickly if you need to rollback changes, because you need to track state manually
* After all the use of 'context' is optional. You only need to pass it if you need cancellation, whereas in async Rust you always need to keep in mind that you might get canceled.
Languages evolve okay, but Rust felt more like it was just right in the making.
That's the problem and stabilization doesn't solve it. Only rejecting language changes will.
This is a syscall after all. First priority is to provide a very general interface and remain compatible, not developer ergonomics.
To get explanations on the optimization decisions by the compiler build your package with:
go build -gcflags="-m -m"
See also: go tool compile -h
go doc cmd/compileIf OOP provides the footgun to shoot yourself, OOP is at fault. Overall the article reads as "OOP has no problems if is used correctly". Of course that's true. I have seen well designed OOP programs, but the majority was not. The author should ask the question, why OOP is applied the wrong way so often.
There is definitely a lot of cross-talk. Can you make an example where my previous comment would be misguided?
Writing testable code is not about dependency injection etc. It's about having the behaviour of a unit clearly defined. This can be done explicitly in text, but also implicitly by using the component in a certain way. If anything beyond that behaviour is tested, you start to defining the behavior in the testcase. This is fine, but often happens unintentionally leading to a very weird and very specific definition of the behaviour.
For example, I work on a component that generates a configuration. I know that the order of lines of the output doesn't matter and should not matter. But the initial author wrote tests that fail if the order changes, because they just check the output against a string.
1. I expect to be trusted. If there is no possibility to work from a remote location and excessive time tracking (e.g. punch cards) because of a lack of trust, I realized that my work was not valuated at all.
2. I expect to be able to use my own workflow. If I get micromanaged and am forced to use buggy toolchains and processes with lots of dependencies, my productivity will suffer and so will my passion. Define the inputs and outputs of my work, but not anything in between.
3. Growth is more important than high pay. I am not talking about a 2% raise every year. There really needs to be a difference based on performance. I throw myself into something and get the same pay rise as if I had been slacking the whole year. This will not lower my performance, it will make me leave.
What's the point of embedding it in vscode especially?
Maybe this will work for developing web applications which are executed on a remote machine by design, but everything else?
#ifdef SOME_CONST
#define HAS_SOME_CONST \
... for SOME_CONST ...
#else
#define HAS_SOME_CONST \
... when SOME_CONST not defined ...
#endif
#define WHATEVER(w, h, a, t, e, v, e, r) \
... common part ... \
... HAS_SOME_CONST ... \
... common part continued ...Nope, ascii more or less represents your keyboard. Using ascii as user input has zero dependencies. Are you really suggesting some binary encoding for formatting, that is only possible with the respective tooling? I see only disadvantages in that.
Whereas in Go, there is always only one reasonable way to do a specific task. You almost forget about the language and just get stuff done.