The 2-to-3 transition turned out to be ten fuckzillion times slower and more painful than expected...

Lesson learned: interpreted languages suck.

I didn't say there weren't. There's shell scripting, scriptable engines (ex. games), query languages, 4GLs for business logic, template languages, etc. But PHP was specifically designed for dynamic server-side code, which needs to be scalable and secure.

PHP is less productive at "getting shit done" than Ruby or Python, and also uglier and more tedious to read, while offering no benefits of any kind. Some programmers would even add languages like Go, Nim, D, Haskell, C#, Java, etc to the "more productive than PHP" list as well, and those languages improve performance significantly.

There has never ever been a good reason to touch PHP (aka Perl for Halfwitted/Hopeless/Harebrained Programmerwannabes). Anyone still using it today is an absolute total retard. Pretty much any scripting language (Python, Ruby, even Lua) is better. But real programmers use statically-typed native languages like Rust, Nim (my favorite), D, Crystal, etc.

Another genuinely free git alternative is fossil from D Richard Hipp (the author of SQLite).

But it's not exactly minimalist, and it didn't catch on in 13 years...

"There is no truth in claims about GPL violations." (FAQ)

GPL communist scum don't leave you alone even if you write your own tools from scratch! 🚁😡

Every piece of code written under a NON-copyFREE license is DAMAGE to the cause of free software!

Lua is indeed superior in license freedom, embed size, and performance.

But it has 1-based arrays and other syntax retardedness that I'd honestly rather be coding Nim (with much better performance and safety).

Also, some people might care that Python was written by a Dutchman, while Lua was started by a Brazilian Jew.

Even if I'm wrong (though I'm not); no one should be punished so harshly as being forced to use Reddit!

No, it doesn't. If you paste code, you need to fix indentation in either circumstance. A decent code editor / IDE lets you paste into current scope (based on cursor position) and fixes it automatically in either circumstance.

In over two decades now I'm yet to hear a single rational reason why off-side rule is worse.

So: Nim.

We're not talking about the "hottest programming language" as in the one that hipsters talk about. Many of the languages you listed are below 1%. C# peaked at 8.6% market share according to TIOBE, PHP at 11.5%, Perl 10.5% - and they've all declined considerably since.

There's really only been 3 programming languages in the last 30 years: C/C++, Java, and JavaScript. All of them were popular because they were the only way to do certain things.

And now there's Python. It's now taught as an introductory programming language everywhere from grade schools to MIT.

Python becoming the default scripting language everywhere (including as an alternative to JS in the browser) would be really awesome.

PHP's usage peaked far below 80%, and has been in decline for years.

You're probably misusing a statistic where PHP is 80% of the X% of dynamic Web-sites that stupidly advertise what server-side scripting language they're running - solely for the benefit of hackers. It also counts every single installation of WordPress, MediaWiki, SMForum, etc.

The real programmers (that have actually made good software that is widely used) use C++ almost exclusively.

Insults without a rational argument only make you look stupid. Writing glue or throw-away code in C++ makes you a slow and terrible programmer.

Cue the fucking retards that say "C++ is too complex".... fucking dummies.

C++ is too expensive - compared to languages that deliver similar execution performance at a fraction of the cost, like Rust, D, and Nim.

No, I discovered a brilliant new programming language among a hundred upstart languages that were a dead-end, was able to appreciate its innovative qualities before 99% of other programmers, and more than doubled my relative productivity as the result.

PHP is a mental illness.

Proper indentation and avoiding useless punctuation noise is not stupid, you are.

As for the other things you mentioned - that's why I advocate Nim.

According to TIOBE, Pascal was the 20th most popular programming language in 1989, jumped to #3 in 1994 (behind just C/C++), #6 in 1999 (behind Perl), and then continued falling. Delphi / ObjPascal is #14 today. So you're off by more than a decade. The hottest programming language in 1981 (after C) was probably either BASIC or Lisp.

It's a dynamically-typed scripting language. Its performance was comparable to its competitors at the time (ex. Perl, Tcl, PHP) but below minimalist languages (ex. Lua, Scheme). These days there are JIT alternatives like Julia and Groovy, but their startup time makes them inappropriate for some situations.

If you want good performance, use a real programming language. Like Nim.

White space as a delimiter (aka the "off-side rule") is an instant IQ test. Smart programmers love it. Idiots hate it.

I was a Python fanboy since around 2001-02, and all my colleagues thought I was crazy... 😜

I hate the whole Web stack. Instead of creating a better way to remotely stream and sandbox apps, they want to take real apps and shove them into the same browser shithouse we should be trying to escape!

A lot of additional features are present through PostgreSQL modules (ex. PGXN) and other tools. I haven't done anything large-scale in years so do your own research.

What I do know is that most of Russia went s/Oracle/PostgreSQL/ when the sanctions hit.

You don't see many of those, perhaps because publishing benchmarks violates proprietary database EULA...

PostgreSQL runs circles around all proprietary RDBMS.

I've been asking this before...

I recommend generating static snapshots to IPFS.

Use Nim - Pythonic syntax with types at the speed of C.

Niggas be like:

def BuyKfc (DwumStickz, Wingz): ...

And then the Jew hired to clean up after the Affirmative Action hires be like:

`` typedef unsigned int t_kfc_drumstick; typedef unsigned int t_kfc_wings;

bool purchase_kentucky_fried_chicken (t_kfc_drumstick drumstick_qty, t_kfc_wings wings_qty) { ... } ``

Too many to list.

Search for php sucks and you'll find dozens of essays, but they barely scratch the surface.

PHP is a horrible programming language in every way, and its popularity was proof of something sinister...

Glad that it declined quite a bit.

Pig. j/k.

See here.

Any programming language without a communist license, a CoC, and a leftist government-loving megacorp sugardaddy would do. For a systems programming language I like Nim and D.

More books at https://wiki.dlang.org/Books ...

The world needs a systems language that improves on C/C++ with zero-cost memory safety, module / package management, and other modern features. Rust is currently the leading contender (although I would personally prefer D or Nim).

Rust wins the most benchmarks and popularity contests in this category. Its module ecosystem is growing at an amazing 38% a year (Nim is second). It is backed by Mozilla, which (although I hate their leftist politics) is one of the largest open source orgs. Heck, Rust topped the TechEmpower survey of the "most loved" programming language for the fourth year in the row!

Furthermore, free open source languages cannot "lose support" entirely. It's not like a proprietary company that can go bankrupt and your investment in skill and code is suddenly worthless. There will always be a group of volunteers to continue making contributions and fork it if necessary. They can become less popular, but there would still be volunteers to maintain them. Heck, there's even an open source BASIC IDE that still runs on (Free)DOS! So everything written in Rust will remain fully viable for decades to come.

From the subsequent month's snapshot:

July Headline: Perl is one of the victims of Python's hype

Python's continuous rise in popularity comes at the expense of the decline of popularity of other programming languages. One of these programming languages is R, but Perl has been beaten even more. Perl is currently at position 19 of the TIOBE index, which is an all-time low for Perl. Note that Perl was at position #3 in 2005 with a rating of more than 10%. The unconventional syntax of Perl and its unclear future (Perl 5 versus Perl 6) harmed the language a lot. Perl 6 has entered the top 100 at position #93 this month, but this is probably too late to become a major player again.

Rust is getting so dominant in the latest TechEmpower benchmarks that even a Mozilla-hater like me must take off his hat and bow...

I do believe that Nim and D could beat Rust, but such effort has not yet been made.

Because most hacking is opportunistic. You find a vulnerability in a piece of server software, and see what people you can find with that vulnerability. You can just pick a target like Facebook and have a good chance of finding a vulnerability there (unless someone makes a major mistake).

Billion dollar corporations can afford a lot of security audits, code reviews, DDoS mitigations, etc.

The best way to hack Facebook is social engineering, like getting a job there and then finding out something from the inside. But such a person would be throwing away a very comfortable six-figure career and risking his neck...

More commentary on commie cesspools: r/programming.

This is some obscure upstart shit... Much vomit...

There are better alternatives in the insane asylum known as BASIC that are actually popular and portable:

Yeah, businessy VM-based ecosystems like Java and .NET have this ability. We need something similar for native systems languages.

I tend to prefer Python/Nim-like OSR, I can tolerate curly braces, and I find the "end" lines most annoying. But it's mostly a matter of personal taste.

What we need is programming languages with modular compiler components and multiple parser front-ends / "syntax skins", which can parse different syntax styles into the same AST. That means you can have multiple syntax modes (ex. Python-like, C-like, Go-like, Perl-like, BASIC-like with "end" lines, etc, etc, etc) without fragmenting the rest of the language tooling, compiler back-end, module ecosystem, etc. You can also have a code formatting tool that converts from one syntax style to another. Then everybody wins.

For a very recent one-man project, this language has very good design choices.

I like "CoffeeScript for C" type languages that add things that C is missing (better syntax, safety, modern stdlib, easy concurrency, compile-time code generation) but without the bloat.

Very importantly, it's a major alternative to Go politically, being a grass-roots project that's not a subtle advertising campaign for one of the most evil organizations in the world today!

Cobol is as uncool as it gets. Tcl was pretty cool before Python. But we've learned from experience that scripting languages cause problems in the long run.

JavaScript was always overrated.

I like Tcl too, but it has flaws.

You are entitled to your opinion. The post is about popularity, not quality.

"This month Python has reached again an all time high in TIOBE index of 8.5%. If Python can keep this pace, it will probably replace C and Java in 3 to 4 years time, thus becoming the most popular programming language of the world. The main reason for this is that software engineering is booming. It attracts lots of newcomers to the field. Java's way of programming is too verbose for beginners. In order to fully understand and run a simple program such as "hello world" in Java you need to have knowledge of classes, static methods and packages. In C this is a bit easier, but then you will be hit in the face with explicit memory management. In Python this is just a one-liner. Enough said."

Everything is relative. Cobol, Visual Basic, Java, Perl, and JavaScript suck a lot more.

No programming language has "fixed all problems", ever. I've been using Nim for years (small personal projects mostly) and it's always been usable enough for me. But v1.0 is a milestone that means no big changes, focus on stability and documentation. The author has been very disciplined in deferring v1.0 release until it was good enough.

Sure, that's another metric with value, but it probably has a lot of overlap with interpreter/stdlib size.

I agree, although library dependencies is probably the biggest issue, especially if you only count those not typically included in the base system. Some LLVM-based compilers require recompiling LLVM, even if it's included in the base system. Haskell, Rust, LDC, Julia, etc seem to take many times more CPU time to build from ports on a base FreeBSD system than Nim.

Anyway, the overarching point of my comment was that most people overlook subtle (but important) technical merits like portability/size/stability when choosing a language, in favor of dumb hipster shit like "elegance" or "popularity".

I agree with you, although I must confess that I'm addicted to some aspects of syntax "elegance" like Nim's brevity, off-side rule, UFCS, etc.

What we need is a well-organized well-funded project to build a proper Unix distro + desktop environment based on rational and consistent design principles. Choose one systems language that's safe, productive, and copyfree (I recommend Nim or D). Just like Microsoft uses .NET and Android / Oracle / IBM / etc use Java. You can also choose one scripting language for automation, but don't overuse the scripting languages for serious programming work.

Guaranteed to be installed by default on any POSIX system

By that logic you should be using ed as your sole code editor. 🤓

Maybe a better measure would be "minutes to install on my favorite POSIX system"?

Nim (my preferred systems language) and Korn shell (my preferred scripting language) have no dependencies, and are available as a package for all BSDs. OpenBSD uses pdksh by default.

Dynamic language interpreter in less than 300KiB of object code

mksh static is 178k on linux.

Compiles to fast machine code with a defined/stable ABI

That's a very long list that includes Fortran, Ada, etc - any my favorite, Nim.

As a license freedom fanatic, there are lots of reasons for me to like Tcl/Tk. As far as I can tell it's the oldest genuinely free scripting language, permissively licensed since 1988, with a copyfree high-level GUI toolkit, and it even uses fossil instead of git(hub). And it gives Stalinman hysterics, which is a great bonus!

But it lost popularity and hasn't been evolving much since the 90s... These days Lua runs circles around it in terms of popularity, performance, tooling, ease of embedding, and even module ecosystem copyfreedom percentage (1761 of 2106 or 83.618% Lua rocks are copyfree; compared to 174 of 236 or 74% for Tck gutter).

I find that general purpose scripting languages are more trouble than they're worth. It has been proven that static typing actually improves your productivity in the long run, especially on larger projects and especially with intelligent editors / IDEs. And of course the performance / bloat avoidance advantages of compiled native code languages are huge.

Modern FLOSS ecosystems have become a "multicultural" nightmare, with every tool written in a different language - with its own run-time requirements, build tools, security problems, and versioning hell. It's yet another SJW poison of our day - apparently criticizing the R-selected scriptkiddie "ruby girl" software makes you a nazi...

Once you have good flexible tools written in real programming languages, you don't need much more than ye olde shell script to automate and glue things together.

This comparison is pretty old, but not much has changed. Plain ol shell (ex. OpenBSD's Korn shell or mksh) can be the best scripting language for gluing together programs written in system languages like C/C++, Rust, D, Go, or Nim. That's what the Unix philosophy of building small interoperable programs is all about.

Seriously, VBA?! 👎👎👎

Nim is available for Android too.

Yup, there are several ways to target Android in addition to Termux. Other examples: dali (not copyfree), nimx, nimes (just uses sdl2). This old forum thread could still be useful.

I understand Go, Rust, D and Nim are all intended as alternatives to C++

They are all systems languages. They can be further categorized by:

• Performance overhead compared to C. Rust usually comes second to C, D / Nim fight for third place, and Go is further behind. But Nim has a secret weapon that others don't: it can use a proprietary native code generator backend (ex. Intel's ICC) to get ahead of D and Rust!

• Having manual memory management (ex. C/C++, Ada, Rust), GC by default that you can disable (Nim, D, Go), or mandatory GC (Swift?, Java?).

• VM reliance. I don't think languages that default to JVM / .NET can be considered system languages, even if they have a "native" variant. All those native variants I've seen so far (Scala Native, Kotlin Native, etc) are far behind the VM variants.

Every time I look at this language and try to do a code doodle it never works... The syntax looks clean but I can never guess how to do things correctly.

Good things do require some effort. If you just know Python, learning any language that comes close to the speed of C will involve new concepts and require practice. A lot of things you're learning aren't specific to Nim and would also be useful for any statically typed, feature-rich, (ultra)modern programming language. Nim does compare very favorably to C/C++, Rust, D, Haskell, etc in ease of learning. It does have hard parts and lots of advanced features (ex. metaprogramming, effects, turning off GC, etc) that you can (at least) initially avoid.

Further recommended reading / watching:

• Nim for Python Programmers

• Awesome Nim - curated list of libraries

• Nim for VScode - currently the best supported Nim IDE (along with (neo)vim). Static typing makes real time suggestions more useful than Python.

• Nim YouTube video playlist

• Nim In Action book

Like, what if I want to print "*" 19 times in a row, or rather create a string that long? In Python you can multiply a string for concatenated repetition but Nim doesn't do that.

Of course it does.

The language developer decided that let s = "*".repeat 19 (also need import strutils prior) is the better default behavior for Nim's standard library. Nim's way is clearer, as you can tell exactly what's happening. Reducing the number of characters to do something doesn't always make the language better.

But if you really want Python's print("x" * 19) to work, all you have to do is import pylib (after getting it with nimble install pylib command). Additional libraries make Nim more like Python, Kotlin, Perl, etc.

How do you get past the extreme-beginner stage when you don't know how to do anything.

Practice, practice, practice. Reading other people's code also helps.

It will also get easier when the language & standard library reaches version 1.0 stability, and there will be no breaking changes and more focus on documentation.

I'm very glad to see Nim getting attention here!

As per Nim's install page, there's no longer a reason to compile Nim by hand. It always provided binaries for Windows. The best and easiest way to install and update Nim on Unix / MacOS is the choosenim tool. There are also nightly builds for Linux, Windows, and MacOS. It's up-to-date in the default package registry for FreeBSD, [NetBSD](http:// pkgsrc.se/lang/nim), etc.

Yes, choose a programming language that's not an advertising campaign for our enemies, doesn't try to subtly trick you into using our enemies' services, is not infiltrated by SJWs, and was not engineered to keep the creative approaches of high-IQ programmers from confusing the low-IQ programmers. Like Nim or D.

Nim - Pythonic OSR syntax, optional GC, close to the speed of C.

Yes, with some tinkering you can do anything (ex. gx). But the central points I've made in criticizing Go remain valid. It's subtle nudging rather than force, obviously; but Go is advertising for Google, and its (lack of) default package management is a major benefit for the centralized power of GitHub.

Github to IHateJewsAndGithub

That's IHateCommiesAndGithub. We only ever mention Jews because it's more edgy and has fewer syllables. 🤓

I have a lot of non-SJW stuff on it and have never had it taken down.

It's not about them taking things down, it's about them having the power. Like I said about the Alex Jones bans: as long as you have backups, them actually taking things down is a good thing. Breaks the addiction.

Python is also vulnerable to this and I'd say more so.

No, it's less so. PyPI is more vetted than an archipelago of tens of thousands of repos (though mostly on GitHub). But I'm not presenting PyPI as the ideal, far from it. BSD ports on IPFS is a better example: everyone sees the same checksum, and you can get it from any mirror - no centralized authority can screw with any "deplorable" individuals the way GitHub theoretically can.

Rust is an advertising campaign for Mozilla.

Mozilla started out as an ally / lesser evil, although they took a wrong turn with licensing. They've since grown into a top source of socialist derangement in free software communities, pushing SJW politics and government control of the Internet...

Better system programming languages (in terms of both culture and license freedom) include Nim and D. (See here for more.)

This is why I've been strongly recommending the Nim programming language, which has many syntax similarities with Python.

Go packages ship with docs locally.

That's not related to the current debate. Go obviously does some things right.

Try using Python with no source coming from Github. Obviously it gets rehosted on pypi.

I've been using Python for a decade before GitHub was a thing, but that's not the point. Some language ecosystems are more GitHub-addicted than others.

I like to joke that "github" is most frequently used keyword in Go code. Go has made deliberate design decisions to emphasize GitHub, which is probably one of the most dangerous power empires in the software industry. GitHub has an extreme left-wing bias, often inserting left-wing "alert" banners (ex. for government "regulation" of the Internet) into all of their hosted code. If some Antifa fan at Google or Microsoft/GitHub decides you're a "nazi", they can inject malicious code based on your IP the next time you run "go get". A packaging system should be decentralized and based on checksums, so everyone requesting a package gets the exact same result.

I don't like Google as a company.

But you are acting in its interest. That's called addiction.

Go is a nice in-between language, a good compromise and very fun/easy to learn. Not everything needs to be C++/Rust which absolutely have their place, but take way longer to learn.

A "nice in-between language" maximizes for multiple variables, usually the tradeoff being between developer productivity and executable performance. Of course the exact rankings would depend on project type and developer preference, but there are multiple languages that are consistently both faster and more productive than Go.

If you were to rank various languages by developer productivity, you would get something like {Python:10, Nim:8, D:7, Go:6, Java:5, Rust:4, C:1}, esp since with a good IDE static typing is a net productivity benefit. If you were to rank various languages by executable performance, you would get something like {C:10, Rust:9.5, D:9, Nim:9, Java:6, Go:6, Python:1}. Sum it up, and Go is a worse "in between language" than D, Nim, Crystal, etc.

Also compiles super fast.

Go is on the wrong side of history with this. Yes, C/C++ compilation is insane, but all modern languages do better. There is a trade-off between compilation speed and compiler intelligence (syntax convenience, metaprogramming and other advances features, detecting errors, providing useful error messages, etc). Go dumbs down its compiler to the benefit of the programmer's CPU electricity consumption, but to the determent of the programmer himself. CPUs keep getting faster and cheaper (especially if you use a supercomputer compiler-as-a-service in the cloud), while human time remains precious.

This is so stupid.

Looks like what I wrote went over your head...

If you're used Go, you'll see there's no Google API specific thing that they're pushing.

Go is advertising, period. It was created to make developers like Google. Yes, I've obviously used it, and obviously it's very subtle because it has to compete with other grass-roots languages. Google doesn't do things except in its own self-interest (which also includes long-term political goals). This is a new era of advertising and customer manipulation.

It's a fantastic language

No, it's an ugly, terrible language that's far more verbose, less powerful, and slower than its competitors (ex. D, Nim, Crystal). It was engineered to make programmers easily replaceable by disallowing advanced features that appeal to intelligent programmers.

and is about as decentralized as you can get.

Try developing in Go while blocking all enemy sites (i.e. Google and GitHub).

It builds basically static binaries that you can ship anywhere.

That has nothing to do with centralization. Every compiled language can do static binaries - but Go is particularly bad at it due to binary size bloat. And it's less portable than Nim.

Avoid """free""" software that constitutes a sophisticated advertising campaign for major government-loving corporations. Those corporations control many aspects of the developer culture in those ecosystems, and manipulate them in various subtle ways to their benefit.

Examples of this in the software world are Microsoft (GitHub, C#, F#, TypeScript, .NET, Mono, and everything built on top of it), Oracle (Java, and everything on top of JVM), Google (Android, Go, Dart, Flutter, etc), Apple (iCrap, Swift, LLVM), IBM/RedHat, Facebook, Twitter, etc.

Examples of more independent grass-roots programming languages include: Python, Haskell, D, and Nim.

Choosing genuinely free software means software you can do anything with independently from anybody else: no legal attachments (no EULAs / licenses, including "well-intentioned" commie licenses like GPL), no cloud addiction, no centralized support communities with a strong left-wing bias (ex. FreeBSD, Node, Ruby).

Just as Facebook and Twitter use their media power to promote the political causes they like and punish those they dislike, so do software companies through services like GitHub, Play Store, Amazon AppStore, etc. If left-wing corporations think it's OK to throw milkshakes at right-wingers, why not inject malware into their software downloads as well??!

See this older rant & comment replies for more info.

Microsoft is not your friend - even if they spend millions of dollars on sophisticated "open source" marketing campaigns to convince you otherwise. Use a genuinely free programming ecosystem that is open source, fully permissively licensed, and doesn't constitute an advertising campaign for a left-wing government-loving corporation.

I use "whitelist" and "redlist".

I wish they'd say "Unix Shell" instead. People who really care about freedom should prefer a freer, more secure, and SJW-free Unix like OpenBSD.

I just wanted to say thank you for writing nnn. 😊

Phones rot your brain. I try to only use mine for things I really need on the go: phone calls, SMS, GPS, and as an MP3 player via VLC (content synced from Unix laptop). If you spend a lot of time browsing the Web on your phone, you need to reexamine your life. Get a real computer!

If you're new to BSD systems, a FreeBSD-based distro like TrueOS or GhostBSD is probably the best place to start. Desktop software runs great on FreeBSD. You can later experiment with a from-scratch FreeBSD install, OpenBSD, DragonFlyBSD, etc and decide what works best for you.

The performance difference between FreeBSD / DragonFlyBSD and Linux is very small to non-existent - depending on your hardware. Some of the difference is due to different compilers used to build the system (GCC vs Clang), since a lot of CPU-intensive software was specifically optimized under Linux and GCC. OpenBSD can also be slower due to absence of a modern FS, conservative memory management, and other trade-offs of the security-first design. You can read benchmarks (like from Phoronix, ex), but the only ones that matter are how those OSes perform on your hardware and for your specific needs.

OpenBSD is a much freer (as in freedom) system than anything based on Linux, but the performance isn't always so great...

The Silicon Valley is far from a free market. It had tons of government R&D money poured into it since WW2, and it's still heavily in bed with Fed domestic spying agencies - especially Oracle. Its use by so many large corporations and universities is all about group-think and historical momentum, not actual quality.

Everything from Oracle sucks. And all Java sucks.

• Use PostgreSQL. Most Russian businesses switched from Oracle / SQL Server to PostgreSQL when they were hit by the sanctions, and it's quickly catching up with the most important features. There are lots of extensions, and proprietary support if needed. Given the cost of Oracle licenses, you can save money by hiring developers to write any features you're missing in PostgreSQL, for the benefit of all humankind!

• Use a copyfree statically-typed programming language like Nim, D, Haskell, Rust, Go, etc. (Strikeouts are for languages from left-wing organizations / corporations that lobby for bigger government.) Some aforementioned languages easily beat Java performance benchmarks, including for low-powered devices and Web scale APIs. Or use a scripting language like Ruby, Python, Tcl, etc - if you must.

• You don't need a heavy Java IDE. VS Code is the most feature-rich editor for the languages mentioned above (ex Rust, D, Nim), and it has a pretty low learning curve. Better still is learning vim or kakoune.

I don't agree. C/C++ Takes more effort than Rust, D, or especially Nim. C/C++ is uglier code, lots of boilerplate, slower development, and much higher likelihood lethal bugs (which can cost a company millions).

With the aforementioned languages you can still write lower-level code with manual memory management that's as efficient as C/C++, and easily interface with all of C/C++ libraries. But 90% of the time using higher-level features and GC is a good trade-off (and they're still faster than Java, C#, Go, Haskell, etc).

Use a simpler programming language like Python when getting started, unless you have a good reason to use a systems programming language instead. The most common second language is Java, which is used for things like Android apps and highly scalable server-side code. There are literally thousands of free Python learning resources on the Internets. IntelliJ has the best free IDEs for Python and Java.

This is not a programming question. This is a "Computers 101" question.

If the programs are free, you can install them on any computer. You can also copy any files from one computer to another (like via a USB storage device as an intermediary). The only complication would be licensing and copy protection from proprietary software, if any.

I guess all the idiots who supported """Net Neutrality""" would be OK with that government power-grab too...

JS is probably the gayest programming language...

Good programming languages have strict static typing, catch errors at compile time, produce lean native code, perform close to the speed of C but with much higher developer productivity, are highly portable, aren't run by left-wing corporations (ex. unlike Go, C#, Swift) or non-profits (ex. Rust), have 100% free permissive license for all major components (ex. Java), no crazy syntax that only math PhDs like (ex. Haskell, Lisp), and no affirmative action CoCs!

Use OpenBSD.

While communists have their own definition of "free software", people who care about genuine freedom (ex. the Copyfree Initiative, Theo de Raddt / OpenBSD, etc) know better.

We have drawn "a line in the sand" against what automagical contracts / legalese restrictions (backed by government force) so-called free software can impose. The Apache license crosses this line.

This transition is very bad news for projects that depend on LLVM, including Julia, Rust, Dlang (LDC), Haskell (GHC's LLVM codegen), Rubinius, etc. And it further vindicates my advocacy of the Nim programming language, which can still work without any non-copyfree dependencies.

I'm a copyfree fanatic, and I've been keeping an eye on UPP / Ultimate++ for many years. Unfortunately I haven't done any desktop app programming during this time, so I never got to use it.

It's been around since 2004 and seems to be chugging along pretty slowly, not sure if it has kept up with all the latest advancements in C++. I'm also not sure if C++ app development is worth the extra effort compared to languages like D - DlangIDE with DlangUI, etc.

Another option to consider is NANA (modern C++, Boost license), and light-weight libraries like imgui (C++, MIT license) or nuklear (C, public domain).

Avoid wrappers around commie GPL crap like GTK, and especially idiotic bloatware like Electron.

Very interesting points, thank you.

It isn't possible to know who 3% of the contributors are, and what their motives are. Checking all source code is virtually impossible.

It may be impossible to kill 100% of the germs, but that doesn't negate the benefits of good hygiene. We need to limit the attack surface (so to speak): know where your software is coming from, in what ways it can hurt you, and have as many eyeballs on that code as possible.

Which I why I argue that we need a right-libertarian software freedom movement to counter the left; defining our philosophy and focusing on specific software ecosystems and projects - ones that are already SJW-free and focused on quality auditing (ex. OpenBSD).

I can think of three ways in which software developers with bad motives can harm you:

• Malware. One must obviously practice good security policies, starting with the highest security and code auditing standards for the privileged code, signed software repositories, and running userland apps under the least privilege possible. If your weather app is malicious, it shouldn't have the power to do anything but display bad information - not have any possibility of allowing remote access, deleting or altering other files, stealing your crypto-coins and other secrets, etc. The odds of you installing a malicious app are very small if the code is cryptographically checksummed and comes from a conservative and discerning repository (like the OpenBSD ports), meaning thousands of other security conscious people have checked this code before you. Using a better programming language with higher-level syntax and better abstractions (like Nim or D instead of C/C++) can make it easier for more people to read the code.

• Legal entanglements. Most people don't pay attention to this, or think that all "free" software is equally free, but drawing a line with license freedom is my utmost requirement. GPL and even the Apache license are not free enough. All permissible licenses merely say: "do what you want, just don't sue me and don't claim you wrote my code". The software cannot claim that you've automagically entered into a contract and obligate you to do anything.

• Ideological propaganda. It limits one's ability to morally condemn MSNBC while being addicted to C#. (Or the Google Memo and Golang, etc, etc, etc.) I once even made a fuss about the 'B' in BSD, but one must pick one's battles...