Refreshing to hear a point of view where it makes sense to have large functions to guarantee sequence and avoid reusing functions.
For some time I thought it was _always_ good practice to split functions up into smaller functions where reasonable. On the other hand I've always hated linters that complain about method length or cyclomatic complexity, as they don't really measure how easy it is for people to understand what is happening.
After all, code is for people, not machines.
Maybe the title of the article is bit unlucky, if it was named "how I made my library faster and more compatible", would that change your opinion?
And yes, it's only a 252 ms improvement, but that's a whopping 44% time saved. If you need to do lots and lots of mesh optimizing, that might be very well worth it.
Seems quite useful, allowing the developer to guide the garbage collector into the right direction by carefully placing statements to tell the garbage collector when it is (not) ok to run. But make sure to add some comments describing the purpose of those statements, and how to profile your code to check whether it's still working correctly. Don't want to accidentally stop garbage collection altogether, either.
I've been in a project where some (authoritative) people had a tendency to split things into separate repositories for very small things, e.g. repositories with a single class. This was pure developer hell. Any change meant changing at least 3 repositories, including a review for each change.
Never understood this decision as all parts needed to be on the latest version anyway. Caused lots of dependency and versioning issues too.
The "code" version doesn't seem to work very well for me on a screen. I'm using vim in Gnome Terminal. It seems to be much less crisp than my personal favorites, Fira Code or Hack (https://sourcefoundry.org/hack/)
That's usually how you can identify good people: when they can explain complicated things using simple words, in a way that their audience can understand it. People that need lots of expensive words and leave you feeling dizzy at the end of their presentation often don't know very well what they are talking about either.
My point was not really to mention a particular programming language, but rather to make the point that people seem to continuously reinvent the wheel rather than reading up on history and investigating other programming languages.
If you only know C/Java/Python/Go and you learn about <radically-different-language>, it will probably make you a better programmer even if you never write a single line of <radically-different-language>.
"it became clear that we needed to ensure that every single condition was handled and accounted for in the code"
This is a feature of several (mostly functional) programming languages, e.g. Haskell. Fun to see that often people figure out that these types of concepts are a smart way to write your code. Too bad it usually means many people reinvent the wheel instead of learning about computer science history and other languages.
I often see a bad split between the ideas/specifications, and execution of a software project. On one side there's the project style where everything is designed and specified by non-programmers (i.e. people who don't end up coding the thing), then thrown to the programmers to make it work. On the other hand there's plenty of programmers that just want to write beautiful code and care little about how useful the result is.
In my opinion you get better results when most people involved are fundamentally problem solvers, some happen to be awesome at writing code, and all are working together closely.
Growing vegetables in greenhouses can be done very efficiently. The Wageningen University researched high-tech greenhouses in Riyad (Saudi Arabia) and found that it only required 5 liter fresh water per kg tomatoes, compared to 168 liters in a low-tech greenhouse [1]. This is possible using a closed system that recycles the water that evaporates in the greenhouse. The low-tech example is a plastic tunnel without such facilities (the most commonly used type of Greenhouse in the Middle East). The yield per square meter was also 50% higher for the high-tech greenhouse compared to the low-tech greenhouse.
Perhaps it's a matter of rule-based versus principle-based view of the world.
Generally speaking, in a principle-based system, there is room for different interpretations of the stated principles. Edge cases usually don't require special mention.
In a rule-based system, rules are strictly defined and enforced with little room for interpretation. Anything not explicitly mentioned is a grey area and edge cases often end up amending the rules so they are covered as well.
Sounds to me like the author prefers the rule-based approach and/or is assuming these rules are strictly enforced.
As I remember from an HR course at business school, studies have shown that experience is one of the worst indicators for job performance (when hiring someone; all else being equal).
In my experience Google has awesome sales people, but the ones I've spoken to have an engineering background. Convincing other engineers that GCP is technically superior isn't that hard, but (unfortunately) engineers aren't usually the decision makers.
You're getting downvoted because you don't base your statement on anything. Google sometimes cancels Early Access or Alpha stage products. Beta products may change before they are made Generally Available (GA), but I cannot personally remember any beta product being significantly changed or cancelled before GA. Any GA product will be stable for quite some time, you will get at least a 1 year notice before they deprecate anything, as can be read from their terms: https://cloud.google.com/terms/ section 7.
But I understand hat some customers require enterprisey products that stay exactly the same for at least 10 years, and a 1 year notice might not be enough to make adjustments.
Which is terrible. Some people think because a github repo has a certain amount of stars they don't have to actually think or look at the actual code in that repo. I've seen devs frowning at github repositories because they "only had x stars" or recommending to "pick the library one with most github stars" as if that would be the best fit for your need.
I feel like Google and Mozilla are acting too lenient here. In my opinion it doesn't matter if you wait 1 month or 2 years to remove support for old TLS versions, affected parties probably won't notice or act until it happens. On the other hand I understand that Google and Mozilla are very careful about user's experiences and their market share.
It's frightening how politicians with such little knowledge and understanding of certain subjects have so much power to create legislation about those subjects. But apparently that's how we have built our civilization, through trial and error.
Flatpak works much better for me on Ubuntu 18.04 with vanilla Gnome on Wayland: the Snap packages don't appear in the Gnome menu (until you launch an X session) and some Snap packages don't work at all on Wayland.
Also, Spotify is updated much more often on Flatpak hub than on Snap.