What Technologies to Learn in 2020?

Learn how to really use a relational database, relational data modeling, and SQL. Not knowing of their capabilities may lead you to unnecessarily complicating your tech stack. You can go a really long way with just this domain of expertise. From there, do the same with whatever key-value store interests you (for me, it's Redis). Python isn't known for high performance but when a django web app uses a cache and relational database effectively, it can achieve a very acceptable peformance. Case in point: the Zulip chat platform: zulipchat.com.

Aside from the database domain, I really enjoy using Rust and recommend it as the next language for anyone to learn, but only after taking time for in-depth relational database training. :).

I know that this might be not a very popular opinion but I am learning Clojure in 2020. I work a lot with data and in my particular job the most important things are rapid prototyping, productivity and level of abstraction. After getting into the basics I find it to be the most intuitive and well designed language I came across. Last time I felt that I could do extremely complex things in hardly any time was when I learned Python.

About the Tensorflow/Keras thing you mention: Imho Keras is dead with Tensorflow 2.0 and the entire Clusterfuck that came along with it made me try out Pytorch and I haven't looked back at it. I was able to convert my model from TF to Pytorch in half a day without any prior knowledge of Pytorch and it works like a charm.

Sorry if offensive or presumptuous, I assume you are max. 30 years old?

Being a freelancer the last 5 years (previously doing webdev part-time for 15 years) and having a couple of long-term side projects, I've been "burnt" enough that I've gotten tired of chasing shiny tech, just for it to become abandoned (e.g. bower, grunt, AngularJS) or introduce big breaking changes (e.g. some upgrade paths in PHP's Laravel or Symfony).

Using Python with Flask was a breath of fresh air (ironically because it's "boring") and trying to keep setup / infrastructure overhead low in the frontend (e.g. using good old Bootstrap, combined with Parcel.js) has reduced debugging significantly so I can focus on developing features. Instead of shiny new tech, I can actually present shiny new features.

It's important to know of the new tech, but I think diving deep into new tech just because it might seem cool now can be frustrating and inefficient long-term.

Of course it depends on what you want in your developer career. I have one profitable side project and 2 more that I hope to make profitable this year. Yes, it took 7 years and they use boring-ish tech (PHP / Symfony and Python / Flask, both using PostgreSQL, and none of them a SPA) but that's ok. I have colleagues who have started 15 side projects in the past 5 years, each using a different stack, but none profitable and none maintained over 6 months.

I came here to tell OP to spend the time learning something like Terraform because it is not a trend or a fad, has wide adoption by the enterprise, gets them closer to the metal in understanding how everything works and will almost definitely help them in their career.

I've instead found a flame war with someone presuming a person's age and preceding to talk about how much better they are ... oh HN why does it always come to this.

You were once a person who knew less. Someone probably helped you along the way too. Just be a decent human and give an answer without trying to prove how wonderful you are

why not something that doesn't seem to relate to your backend work at all, e.g.

Dennis Yurichev's Assembler book will take you all of 2020 to finish :-) (aka "Reverse Engineering for Beginners"): https://beginners.re/RE4B-EN.pdf (see also HN discussion https://news.ycombinator.com/item?id=21640669)

Erlang and BEAM is incredibly cool concept: https://www.youtube.com/watch?v=FonRzASOkZE

I also really like Nim: https://nim-lang.org/

Or something totally different: learn about BGP, BGP-sec and modern alternatives, e.g.: SCION https://www.scion-architecture.net/ ...

Security Engineering is essential reading even (or especially?) if you're not working in infosec: https://www.cl.cam.ac.uk/~rja14/book.html

Or/and look at which new RFC's might give you ideas for cool side-projects and then use the new language to come up with something -u-s-e-f-u-l- FUN to build.

IMHO it's a good idea to learn things at different points on the adoption curve - learning to balance "cutting edge" with "already widespread, I just haven't used it" helps in making good judgments about tool selection for projects.

Reactive component frameworks: I've been quite happy with Vue. I'm interested in learning Svelte - don't know if I would use it for production yet, but it's definitely gaining traction and has some interesting ideas. (The compiler-based approach makes a lot of sense, especially with wasm on the horizon and the desirability of cross-compiling to native mobile platforms.)

Visualization / mapping: Mapbox GL is amazing, to the point where I can't recommend Leaflet anymore; the only major hurdle is their style spec, which makes a lot more sense if you have some exposure to LISP-like languages. AFAICT d3 remains the gold standard for interactive visualization, and the micro-library approach of v4 / v5 means you can take advantage of things like webpack tree-shaking. I'd love to play around with Observable notebooks as an alternative to Jupyter.

Databases: PostgreSQL + PostGIS. If you aren't _deeply_ familiar with the many awesome features of this combo (vector tile generation via ST_AsMVT, functional indices, full-featured JSON support, transactional DDL, etc.), take the time to become familiar; there's a good reason SQL is the new NoSQL :p

Other things of personal interest, in no particular order...I'd love to learn more about HTTP/2, GraphQL, wasm, ways of organizing CSS, and ways of organizing ETL / automation pipelines. For languages, I'll usually run through tutorials every now and then to get the feel, but other than that I largely take a "just-in-time learning" approach.

I am the maintainer of these roadmaps https://roadmap.sh/roadmaps if it may help.

We are in the middle of updating them for 2020; frontend roadmap has been updated, backend and devops are expected to be published in the next couple of weeks. Also, one of my goals this year is to make these roadmaps interactive with clickable nodes, adding details for each and making them easier to follow for beginners.

For context, I’m 45, but was an “expert beginner” staying at one company for over a decade before I took my career seriously a little over a decade ago. I also don’t live on the west coast where both salaries and the cost of living are both far beyond normal.

My experience from being in the job market frequently, watching trends, talking to people in the industry locally and recruiters, is that it doesn’t take more than about 10 years to reach your salary peak as an individual contributor or even as a hands on team lead/architect no matter what “technology” you learn. Not saying that’s a bad thing. I’ll take more money if it is given to me, but that’s not really what I am optimizing for.

What I am optimizing for is to stay current with the trends and to know enough technology that is on the “Slope of Enlightenment” phase of the Hype Cycle. I’m doing that by making sure that I am both working for companies that are not using outdated or unmarketable tech and doing resume driven development. At 45, I can’t afford to be an out of touch old guy and then start whining about “ageism”. That’s good enough to get the “right now job”. Meaning if I need a job now I can email some recruiters and have another job within less than a month as a bog standard Enterprise CRUD Developer/Architect.

On the other hand, if you just focus on “technology” you’re a commodity. There are thousands of people who know “technology”. You can get a job quickly but it won’t pay that much above median.

Focus on architecture and how to deliver business value. I know plenty of “smart people(tm)” who can’t deliver code that makes money or saves money worth crap. This is the key to negotiating your way out of being another commodity developer.

Although to make a lot of money, knowing technology that is on the “Peak of Inflated Expectation” may help you to overcharge as a high price consultant by going after VC funded companies with no business plan and plenty of access to money. The best way to make money during a gold rush is by selling shovels. Right now, for me, that focus is “cloud consulting” or being a “Digital Transformation Consultant”. When and if that starts trending to the “trough of disillusionment”, I can always fall back to development.

If you're in the web sector, definitely give a try to wasm. Have a go at Rust while you're at it — see what I did there?

I'm personally hot for GraphQL because it's a powerful paradigm to model data.

Both Go and Rust are incredibly interesting languages, in very different ways.

In some ideal world, Go fits in a scaling/efficiency vertical somewhere in-between C and C++ (it's very specific but it basically encompasses all middleware, many microservicing archs, and most 'simple' projects at the edge).

Rust is more of a C++ juggernaut that does it all, if it prevails it'll be applicable to anything and everything.

Both have extraordinary great communities, very welcoming and attracting many great minds. Support is all but guaranteed for the next decade. You just can't go wrong with either, imho, just pick one that fits your domain best.

I'd be happy to work in both.

In a word: biotech.

Okay, yeah, that's a bit beyond the scope of your question...

Tech-wise I think the stealth silver-bullet will be "Categorical" programming†. When this hits it might even contract the job market for programmers.

Compiling to categories" Conal Elliott http://conal.net/papers/compiling-to-categories/

† As in a kind of PL paradigm: https://en.wikipedia.org/wiki/Programming_paradigm

Mathematics. Its Probably just another fad that will prove worthless next year, but I'm jumping on the band wagon for now.

> +1 if you suggest something cutting edge that very less people know about!

Well I would suggest learning about The Fuchsia Operating System (a new OS by Google) which is extremely cutting edge of OS Development and its kernel (Zircon) brings interesting concepts to the table in terms of design and implementation. It is bleeding edge enough that Flutter is used for the new apps, Rust is used for the drivers and the netstack uses Go and a official port is already on the way to upstream.

All the Flutter apps, you're making will run instantly on Fuchsia, and in this decade, I would place a bet on Fuchsia to be the successor of both ChromeOS and Android.

"It is always good to keep yourself up to date with the hottest tech stacks."

It’s good to be aware of new stuff, but it’s also a good practice to have a firm command of some well established technologies that have strong support and resources behind them.

It’s been my experience that I get more work done when I can easily find sample code and multiple explanations for API calls. Experimentation and R&D to figure out some bleeding edge stuff may be fun but it’s a lot slower and less stable than using tried and true methods.

It's not a 'hottest tech stack', but I would suggest people take 2020 to learn testing. TDD/unit/browser/whatever - look to incorporate testing in to your work more often. For me, that has meant making sure code you're writing is testable first. I don't do hardcore TDD, but often am writing tests more or less concurrently with little bits as I'm writing those bits.

I don't do this for every single project all the time - I do work on systems, that are, essentially, non-unit-testable. While refactoring could be done, clients/owners refuse to give appropriate time/resources to move in that direction. That's their choice, and they pay the productivity price (and often, are acutely aware of the situation but solider on anyway).

However, for my own projects, testing/testable code is an increasing focus, and has helped my own code/projects to be easier to think about up front, and easier to modify/maintain/refactor later.

It’s probably worth learning some AI so you know what “AI” really is (it’s not magic) even if you don’t use it - it can help cut some of the hype you hear. I recommend fast.ai for that.

If you know JavaScript and want to make mobile apps, give React Native a try! It’s a good choice for most business apps, and even some games.

I am planning to focus on Go and developing a deep understanding of computer networking. I think with cloud, IOT, increasing importance of cybersecurity, understanding the nitty gritty of networks is going to be increasingly important.

Elixir / Phoenix. Specifically: Phoenix LiveView.

I've spent the last five years building SPAs using mainly React and see LiveView evolving as a compelling alternative.

From what you've mentioned, I'm focusing on Go and GraphQL professionally (I'm a backend engineer). Flutter will definitely get looked at. Something I'd add if you also spend time in backends is infra - choose a system (probably AWS, GCP, or Azure in that order) and a infrastructure-as-code middleware for them (e.g, Terraform). More and more these days, the provider is now part of the stack.

If you are into smart contract development on Ethereum.

A new language called Vyper as an alternative to Solidity has launched that said to solve some of Solidity's shortcoming

https://vyper.readthedocs.io/en/latest/

But it's so new that there aren't that many resources and community around it yet

If you are on the java platform I have an unpopular recommendation: get familiar with OSGi. Its specs, its history and its core concepts. The learning path you go will teach you a lot about how to build systems, how to think about api design, modularisation and standards (compared to one-off company owned tech). Its almost certainly makes you a better developer/thinker.

Your suggestions seem a little over the place. I suggest focusing on a single language instead.

Personally I would advise you to learn Rust and learn it well. Forget wasting your time on ”hottest tech”, Rust is here to stay and will be used for decades to come. The official Rust (git)book is a great resource to get started.

If you want to build for the web, learn React or Vue as well (but probably not both).

Something that will still be useful 5 or 10 years from now. Functional programming / Low level programming and etc.

I can't say this is what you should learn, but what I've been learning recently and enjoying:

1. Ionic Framework with React/Typescript (https://ionicframework.com/blog/announcing-ionic-react/). I've never done much frontend work or mobile development before, but it's a lot of fun. Ionic makes it easy to make a PWA and access native device functions. Typescript is one of the nicest languages I've coded in - the type inference is wonderful and the linters catch a ton of mistakes I wouldn't have otherwise.

2. Flask + Python. Really enjoy the simplicity of Python. I've been getting into type annotations with MyPy. I honestly have mixed feelings about Python - for small projects/exploring data it's been fantastic, but I feel really limited by the lack of type safety when things get bigger. I've also been playing with some BDD frameworks (behave and pytest-bdd), since I really want to get a better understanding of how to build effective testing infrastructure.

Learn everything about vanilla JavaScript really well. Just vanilla.

Learning what's new and shiny is great, but try to spend time this year building something, seeing it live in the wild, fixing and debugging it, nurturing it. Build on your critical thinking.

Perhaps do that with a new technology :)

I think a lot of the world hasn't heard of Dhall (https://dhall-lang.org/) but could make good use of it.

It's a sensible configuration language with types. And the Haskell integration is quite good.

For web frontend, Svelte.

I did a year and a half of React/fullstack dev and really didn't like it. (disclaimer: was a fullstack dev for many years but focused on backend more, and only worked with jquery frontend before 2017).

My next (current) job is backend dev so I haven't gotten a chance to do frontend professionally again; I briefly dabbled in Vue and liked it; and then I discovered Svelte and like it even more. I started working on personal projects in Svelte and hope to learn a lot more. Honestly I'm just hoping for Vue or Svelte to take off as they seem just much more sensible than React, but React is a giant now and doesn't seem to go away any time soon.

What's surprising is that the question is "what tech to learn?" but most answers (also his own suggestion) are mostly about frameworks and programming tools.

My suggestion would be to actually look into "tech" such as distributed systems (CAP theorem), DDD/Event driven architecture, CQRS pattern, workflow automation, etc ...

Just went from building small Vue projects to trying out Svelte and I'm really enjoying Svelte.

It's made some things a lot easier, even though I'm now forced to use the npm toolchain. Previously, I liked to just include the Vue files necessary.

I'm finding how Svelte does binding and lifecycle much easier to deal with. Vue's template system was making data flow more complicated than it needed to be, or it was just my misunderstanding that made it so. Regardless, I was able to re-create an small app (that had some template complexity causing me problems) much easier/quicker in Svelte.

I am really liking Quasar Framework for quick Vue development. It bundles a bunch of things that are annoying/confusing to new Vue devs (config hell) with a lot of niceties baked in by default: linting, hot reload, tree-shaking, etc. And it has a strong frontend UI on par with Vuetify and has good documentation.

Basic survival. Swimming, foraging, fire-starting, hunting, etc.

I’m personally investing time to level up my proficiency with digital content creation tools — Houdini, Unreal Engine, Unity. They mostly only apply if you work in games or visual effects, but they’re a blast to play with even if your day job is in a completely different industry.

Some frontend framework with fine-grained DOM updates like Solid by Ryan Carniato, Surplus or Svelte.

Why: Frameworks that use fine-grained DOM updated currently top js frameworks benchmark [1]. Svelte lags a bit behind in performance but it offers a better developer experience

[1]: https://rawgit.com/krausest/js-framework-benchmark/master/we...

I'm currently experimenting with Futhark. It's a ML-style functional language that targets the GPU. It has nice Python/NumPy bindings so it's pretty easy to offload some computations.

There's also accelerate although that sort of ties you into the Haskell world.

Generative Adversarial Networks

Is it actually always a good idea to keep yourself up-to-date with the hottest tech stacks?

We picked up the first angular, because of the “keep up mantra”. That turned out to be a complete waste of resources when the second version released. I’m not saying that it can’t be valuable, but these days we build 70% of our stuff with python, Django for web with a minimal amount of JS because it turned out our clients actually didn’t want SPAs. The rest we build in C#. When I look at the job market in my region of Denmark, almost every job is for JAVA, C# or PHP. No-one is hiring for Rust, graphql, go or any of the other hipster languages / frameworks. People are hiring for modern Angular (along with C#), but no one is hiring for the original version. So it’s frankly entirely possible to skip entire “hot tech stacks” without it being a disadvantage.

If you ask me, you shouldn’t pick up things until you need them. Unless it’s for fun, but who learns a new web-dev related framework for fun?

My goal for 2020 is to STOP learning new langs/frameworks/etc. Stop being focused on the process and MORE on the outcome. What i'm building. Why I'm building it. And fucking complete some shit. I have 10 SaaS's in dev at any one time and haven't shipped anything.

2020's are going to be about me shipping crap instead of starting and jumping to something else. No more wasting time.

Calculus, linear algebra, and C will be hot as fuck this year.

NestJS. This is probably the best thing that happened to Node.js ecosystem to write maintainable backends.

https://nestjs.com/

I would say if you have an appetite for learning something new, then pick something which nicely complements your existing knowledge and broaden your horizon.

For example, if you are a Java/C# corporate developer then maybe learn something different like Go, Rust or go for a complete paradigm shift and look at a functional language which will teach you complete new things and change your overall thinking of software development.

If you have been mostly doing backend why not learn a frontend language? Just pick one which you like the most from your initial gut feeling, don't overthink it.

If you've worked with a lot of dynamically typed or interpreted languages, then pick one which is statically typed and maybe compiled.

Basically, just learn something truly new, which will most certainly teach you something regardless if you will continue doing it for a long time or not.

- Svelte, a compiled front end JavaScript framework https://svelte.dev/

- Nix, a functional package manager https://nixos.org/nix/ basically, to install stuff, instead of running `sudo apt install your_package` you edit `/etc/nixos/configuration.nix` and then regenerate your OS from the config stored in that file using `nixos-rebuild switch`. The benefit is that then you can take that file to a new computer with a new installation of NixOS and regenerate much of the state of your system just with that one file.

- QUIC and HTTP/3. I think you have to read the RFCs starting with HTTP/2 to understand it, but really I just mean that you should be aware of them. I think HTTP/3 should start to really exist some time this year and you should consider enabling it in nginx once it becomes available.

- Rust

- A dependently typed programming language like Idris https://www.idris-lang.org/ https://www.manning.com/books/type-driven-development-with-i... or Lean https://leanprover.github.io/tutorial/ or one of the older ones like Coq or Agda https://plfa.github.io/

- Python type hints and async

- Deno (JS runtime by the creator of Node.js) https://deno.land/

- zstd, a relatively new compression algorithm https://github.com/facebook/zstd https://quixdb.github.io/squash-benchmark/

- BLAKE2b, which is the new hashing function you should be using. It's faster than MD5 and cryptographically secure. https://blake2.net/

- Keras

- How to make VR applications (probably with Unity).

Not technologies:

- Homotopy Type theory https://homotopytypetheory.org/book/

- Zero Knowledge Proofs

I’ve recently redone our work CI setup with Typescript + Vue.JS + VueJS Bootstrap on the frontend and Typescript + Prisma on the backend - it’s been awesome so far. Took a little while to get the setup right, but it’s an excellently productive combo and I’ll continue to use it in 2020.

For my own learning, I'm pursing three things:

1) Elixir: since I teach it, I pretty much need to keep digging further and further into its ecosystem, looking for useful things to share with my audience and looking for better ways of building things. For example, the series I'm in the middle of is on LiveView and the next in my queue is on Absinthe/GraphQL. I knew nothing about LiveView a year ago and spent a good amount of time last spring struggling with various Absinthe-related tasks. A year from now there will be even more "must-learn" libraries.

2) The intersection of development and marketing: as a developer, there are marketing systems I can build by myself that would be very difficult for most smaller online businesses to do, but also highly valuable. I've been taking some of Brennan Dunn's courses (working on his ConvertKit course at the moment) and it's been one of the best investments I've made.

3) Rust: I don't have any business reason to learn Rust at the moment. However, it's a particularly good complement to Elixir. Elixir's strengths are stability and productivity, but it's a bit weak in brute force number crunching. Compiling natively invoked functions in C/C++ has been a thing for a long time, but at a terrible cost. If those functions trigger an exception, they can take down the entire EVM, negating the famous stability of Erlang/Elixir. Rust, on the other hand, is very good at making the most of the CPU and memory available in a manner that guarantees safety. So NIFs written in Rust can be used in Elixir projects without fear!

I'm also interested in using Rust with WASM, so there are multiple ways I can see learning it paying off down the road.

For anyone out there learning Elixir: You might want to check out Alchemist Camp. I've had overwhelmingly positive feedback from people who have used it to learn Elixir from scratch (https://alchemist.camp/episodes, scroll down to the bottom and click Lesson 1)

IMO go for timeless:

SQL

Write your own SQL db as an exercise

Regular expressions

Basic multivariate statistics (linear and logistic regression)

Can I ask you what you are trying to achieve and why you are looking for this advice?

A related question that I’ve been thinking about: What technologies/languages/tools/stacks can I learn now, that will still be relevant and useful in 2025, or 2030?

If you value meaning over "hot", I would say the MLIR compiler framework has the chance to accrue lots of value and meaning over the next 10 years. MLIR builds on top of LLVM to provide a new API layer for writing modern compilers, which will be important for languages targeting heterogeneous computing platforms (ML workloads, HPC, etc). Lot's of the ML tooling in Tensorflow is already being moved into MLIR.

Today, my background is 25'ish years in security design.

My near term aspirations about the ideas that will matter in 10 years from now include more functional programming with Haskell's QIO monad for basic quantum related concepts, understanding GANs, the gremlin stack for graphs instead of cypher, and maybe some category theory. Solving problems in these areas is the foundational knowledge for the next 10-20 years in tech, imo.

The next thing I can see myself playing with is Yew (https://github.com/yewstack/yew).

We've been moving to Rust in our backend, being able to share some of these lessons (and code) with our front end would be really neat, in addition to being able to take advantage of the new features coming down the pipe for WASM (multithreading!)

The Bazel build system. As time goes on we're going to have more languages, more runtimes, more packaging requirements. It's pretty clear there will not be "only one" language. Right now we don't have a build system poised to manage complex deps while linking multiple languages, code generation for multiple language targets, etc. Bazel is the closest thing to this yet.

It's a universal build system.

- Programming Language Paradigms

- Algorithms and Data Structures

- Digital Electronics

- Compilers

- OS

- Networking

- Math for CS

- Distributed Systems

Why aim for hottest new stack before you solidify the foundations, then the hottest new tech should be a smooth ramp up? Or am I old school?

Haskell, and Clojure

I think I will invest some time to learn Web-GL and how to make sharers. Since it seems to be more and more important for Front-End development.

- https://socket.io/

- https://www.react-spring.io/

- https://react-hook-form.com/ (I like the "Library Code Comparison" section on desktop comparing the code to competing libraries side by side)

I like any landing page that's straight to the point and gives you all the information you need above the fold without forcing you to scroll down through some parallax nonsense.

In general I think landing pages are overrated though, particularly for Saas applications and ecommerce. Just show me the damn product instead of putting me on a scavenger hunt to figure out how to demo it only to slap me with a login wall!

On a lighter note, all the crypto ICOs had pretty impressive landing pages. I guess when you're running an online pyramid scheme, the landing page itself is the product.

Blazor. I stopped doing development work about five years ago because JavaScript seemed to be taking over everything. I absolutely hate JavaScript so I ended up making a career change to not have to deal with it anymore. Blazor (and other compile to wasm frameworks) lets you avoid 90% or more of the JavaScript nonsense that makes up modern apps.

I work in ML and the trend I see is for Solutions rather than isolated technology. MLops is used now to refer to the infrastructure to deploy a ML pipeline end to end. This includes: VMware, Kubernetes and Docker, Apache Spark/Apache Beam, TensorFlow/Pytorch and Pub/Ub technologies (Ignite, Pub/Sub)

For 2020, I am looking forward to shipping a couple of products for my "stealth mode" startup ;) - using boring stacks I know well PHP/CakePHP, Python/Flask, Java/Dropwizard with the ever reliable Postgres, and maybe Elasticsearch.

As for learning new skills; for the first half of the year I'm playing with Docker more, TUS for file uploads, Apache Pulsar for Pub/Sub, Armeria for building HTTP and RPC services (especially focusing on gRPC services), MQTT for IOT, building USSD apps and WhatsApp bots for different applications as they are increasingly popular around these parts (Africa).

The latter half of the year will focus on mobile development with Android, GraphQL, ML and hopefully get back into Computer Graphics with Processing.

Let's go in another direction here, away from a lot of the hype and cargo cult. I will suggest IntercoolerJS [1] and TurboLinks [2]. These are simple javascript libraries that let you do much of the slick in-dom updates without all the hassle of build pipelines, JSX, or functional paradigms.

I have deployed this in production for clinical trials applications as well as into side projects. Using this with Django means I have a lean, mean, and simple stack without a complicated build or deployment process.

[1] - https://github.com/turbolinks/turbolinks

[2] - https://intercoolerjs.org

Instead of learning a new bespoke technology, How about learning more fundamental, lateral concepts, that potentially could apply across technologies. e.g. https://brilliant.org/

SwiftUI. I think Apple will put a lot of effort into it to be on the same level with UIKit. SwiftUI makes developing UI easier because it is declarative just like React Native and it takes less time to build your typical CRUD app on the apple platform.

I'm learning about Dgraph and the variant of GraphQL it uses as a query language.

Triple stores have always been useful in niche applications, but the scaling capabilities and ergonomics of Dgraph could make it more broadly appealing.

another angle: take a look at evergreen things like relational algebra, logic, graph theory, lisp, regular expressions, emulation, …

that said: I’m playing around with clojure, rust, k, spark ar, raspberry pi

Learn 3D graphics/game engines. Learn enough Blender to be useful.

As AR/VR go mainstream, these will become important skills similar to CSS or basic design skills for 2D applications.

Quantum logic and programming. Given the demonstration of quantum supremacy, AWS expanding into QC with their Braket service, and MS releasing Q# in 10-20 years this will be one thing you will want to have learned. All of the silly JS frameworks can wait. The ML world gains massively due to underlying speed gains of QM. Security considerations will have to change drastically. Having a head start here is extremely valuable given the steep learning curve of QM/QC.

C Programming

For me it's really learning Django with https://wsvincent.com/books/djangoforprofessionals

really learning postgres with https://theartofpostgresql.com/

trying out typescript on a side project

and migrating one project from heroku to docker + terraform

Learn Cadence Workflow (https://cadenceworkflow.io/). It implements a new way to build distributed systems using fault tolerant virtual memory. It lowers the complexity bar for hardcore backend programming by eliminating the need for managing the application state through databases and queues.

Invest in projects that have maturity and staying power. For example, Python, Django, and Postgres offers a mature stack for web development.

Learning to become more creative so I don't have to chase new languages or frameworks for intellectual stimulation.

I am learning Rust and seriously considering Next.js.

The motivation behind learning Rust is that I wish to have a systems programming language in my skillset and I generally love low-level system stufff.

I am planning to learn Next.js because I have just started learning about Server Side Rendering (SSR) and it Next.js seems to have a lot of traction.

What’s the community stance on Linux certifications? Taken as a granted for people to take you seriously or not so much? Does HR generally require it where you’ve worked? Etc.

Asking for myself really. I’ve been around tech and Linux/*nix since 2.4 was the new shiny, but don’t have the RHCSA/CE. Have A+/S+, BS math.

Learn statistics. It will help you to understand that most people don't understand statistics and the world is therefore full of bullshit. (See also https://www.callingbullshit.org/tools.html )

I am focussing on Event Driven and Reactive programming models using Kotlin. Any wise words for me?

Edit: Also GKE and Firebase.

I'm going heavy in to a container first / cloud native workflow this year, mixing a few existing tools I know (Consul, Terraform, Prometheus, Grafana) with some new ones: NATS Streaming, Nomad, Vault, Loki, Drone and minio.

Also want to get good at Makefiles (and play around with jsonnet if I have time).

I’m going into Scala + Akka. There is a slight possibility my company will adopt it instead of current stack.

Kubernetes - both the platform itself and the programming & extension model - is a great area to get involved in. Some interesting things to look at include development workflow tools such as skaffold.dev, serverless computing using knative.dev and service mesh.

Standalone keras is at the end of life, so if you want to use deep learning use tensorflow (api is still named keras) or pytorch.

I thinl computer vision is getting big. Many companies have problems which can be solved with CV, however only view companies can provide solutions.

One good thing about the hiring process in Amazon is/was that the "hottest tech stacks" in a candidate CV received zero brownie points.

I's amazing how many candidates would fail on basic reasoning skill, programming, OS internals, security.

WebAssembly seems like the most interesting thing to come out in virtual machines in a while; in theory if you build something for wasm then you can run it with native performance in all kinds of browsers, as well as, for instance, in Fastly's edge nodes. Fastly released their wasm compiler and VM, Lucet, last year; it can spawn new evaluation contexts about an order of magnitude faster than Linux can spawn processes. For security, that's potentially a big deal, because it means you don't have to reuse those evaluation contexts.

Golang is very practical for building systems. But it's worthless for building libraries except for Golang. Rust seems poised to displace C and C++ as the standard language to write libraries you can invoke from any language, and you'll be able to get better performance with Rust than with Golang. Maybe it's going to be as practical as Golang for writing systems too, I don't know. Parametric polymorphism is definitely a point on Rust's side.

Computer security in general is a really big deal. Unfortunately, 95% of the market is fake, like, 19th-century patent-medicine fake. Sooner or later the people who are doing real security instead of fake security will come out on top, but possibly only after the next major war.

Observable (d3.express) looks like it's probably going to be the way people write software in ten years. But probably not on ObservableHQ's SaaS offering, which may mean not in Observable's language.

If you're writing stuff on the JVM, use Kotlin or Clojure, not Java. There is literally no reason to use Java rather than Kotlin except if your cow-orkers don't know Kotlin yet. Despite its heavy costs, the JVM is a really useful skill to have in your utility belt, because of Android and because of all the libraries already available on the JVM.

Embedded development is really hot, and getting more so, as computers get smaller, cheaper, and lower power. You can get a computer now for less money than a transistor, if the computer is one of those 4¢ Padauk OTP jobbies and the transistor is a common transistor like a 2N7000. Right now this is all done in C, C++, and Arduino; Rust might get there soon, but the JVM won't.

By default, for embedded development, you should probably be using a BluePill or an Espressif board (with the Arduino IDE, if that's what you like) rather than an old AVR-based Arduino. The STM32 line used on the BluePill has an amazing selection of chips; the GigaDevice GD32 line of STM32 clones looks really appealing, but I don't have any yet. It looks like GigaDevice is going to offer a RISC-V version.

That's at the low end; at the high end, we have unprecedented computing power available, but generally no way to program it effectively, as in the days of the 1970s "software crisis". The things we know about that do get real benefits from this massive computing power include signal-processing algorithms, linear algebra, and artificial neural networks. Probably learning about numerical methods and signal-processing algorithms would be a good idea. The software tools (Numpy, Octave, Tensorflow, GLSL, CUDA) are important but secondary.

Provers got a lot better in the last decade; Lean, based on Coq's CoC, is good enough that Kevin Buzzard is making real progress in formalizing mathematics with it. People are also making real headway with HoTT-based systems. It's becoming practical to actually do machine-checked proofs for the first time, which means maybe we can automate a lot of the reasoning process involved in programming.

Speaking of which, Hypothesis can get you a significant amount of that extra reasoning power already, despite not attempting sound reasoning; if you're not using Hypothesis or something similar for your testing, you should be. It's worth writing a Python binding for your C or C++ project so you can test it with Hypothesis. (Alloy and TLA+ might be similarly useful as a way to verify higher-level models; Alloy, like Hypothesis, only looks for counterexamples, but it evidently finds them often enough to be very useful.)

SAT/SMT solvers like Z3 can be applied to constraint satisfaction. If you're not familiar with constraint satisfaction, basically the idea is that instead of writing the implementation, you write the tests, and the solver figures out the implementation for you. This is the way virtually all parametric 3-D CAD models are done, which is itself an increasingly interesting area, precisely because the cost of embedded computers is now low enough that we can surround ourselves with enchanted objects.

In terms of webdev, the most interesting thing I've seen lately (other than ObservableHQ) is Streamlit; it's a lot like React or redo, but running on the server side to render a webpage.

Who knows what's going to happen with cryptocurrencies, but you should at least play a bit with Bitcoin.

I like learning things that are both trending and in demand.

So, for me, the next thing is trying to build something with React Native and Go as they seem to be very trendy and in increasing demand.

Go, I am biased towards it because it's the first language that made me love programming outside of pure functional languages.

I also think AI/ML will become even more important.

I just learn whatever is needed for the product I want to make. After being a programmer for a long time it's very easy and fast to learn basically whatever.

Data structures and algorithms, because I'm transitioning from data scientist to machine learning engineer. Better pay, more technical and less marketing.

learn Rails

Docker + Kubernetes. Cutting edge: https://kustomize.io/

For Java I think Enterprise application servers remain key. This is nothing new but knowing jboss, tomcat, websphere and friends will give you an edge. Also certificates like OCA, OCP aren't useless and provide concrete evidence you are what you say you are. On the front end Angular pops up frequently on job listings and you will not likely be considered for those even if you have frontend experience if you don't know it.

Agree with other meta-comments here on the question itself. FWIW some other random biased suggestions:

* Kubernetes * Rust * Terraform

I am always at the edge with my computer science basics. Someone who doesn't know their carnough diagrams, someone who can't make a simple computer using logic circuits, who can't understand the math behind finite state machines or constraint programming is never able to get ahead of me no matter what new cutting edge tech they read on a blog or news site. So yeah, I recommend back to basics.

Is investing time on VR/AR worth it?

If you learn some new tech and then don't use it you'll just forget it. Learn reactively.

rust, for high and low level (compiler, native, embedded, wasm)

beside that I'd like to get into advanced FP (PEval, effects) and advanced combinatorics.

but right now I'm trying some vuejs (mildly suggested, it's not revolutionary but it's a very nice thing to work with.)

I would say keep an eye on Apache Arrow, it can potentially change how we operate with data.

Learn Haskell to open your mind

- terraform with Kubernetes

- boilerplate Golang stack for productivity

- computer vision fundamentals (for school)

Just build things and you're gonna learn many technologies along the way

Clojure

ROS2 is high on my list for learning this year, as well as Rust

Unsupervised learning

I would rather focus more on what I touched in the past.

bpftrace is coming in Ubuntu 20.04 LTS and knowing it will make bards sing epic tales of your heroics.

ML, NLP, NER

OP are you satisfied with the N answers you got? Was it better than seeing an SO questions chart or github trends?

Elixir is on top of my list.

Pytorch

Webassembly, React Native

FPGA/SoC for me.

Any of the 100 cra... JS libraries that will show up in 2020 will be fine.

Category Theory

Linear logic.

Angular

I'm an Eng Manager and half of my learning time in 2020 will be focused on developing better management/leadership skills. It's something I've found comes with little mentorship opportunities in tech and is also hard to find others to reach out to / network with for mentorship opportunities.

The other half / pure tech - taking on some of the stack that has largely been abstracted by other teams as I've worked, namely CI/CD/Ops/Monitoring for distributed, containerized systems.

I'll probably build something with:

- Go on the backend

- Typescript + React (maybe Vue) on the front-end

- Postgres (really want to master this)

- Redis for caching

and get it built and running on AWS with Kubernetes. Don't know what I want to do for logs/monitoring/dashboards etc. as I've experience with ELK (don't enjoy it), Splunk, Sumo and others but it's not as important a choice to make right now.

Depending on how well that's going I may write a mobile app with Flutter or React Native for whatever is built to round it out.

I have to say though, and I don't know how many others here feel the same, I am getting some sense of anxiety over having no knowledge of or practical experience in ML/DL. Is that justified? Part of me is tempted to invest the entire other half of my learning time into ML/DL for at least the first 6 months and I'm still talking myself down on it.

Do you think graph databases will rise?

Kotlin is my new favorite language. You should give it a try. Fighting syntax noise, clutter, boilerplate and redundant repetitive work is a big chunk of what define a modern language, and at this, Kotlin is probably the best. It will make you more productive AND happier. BTW using new languages that have relatively poor ecosystem (go, rust, swift, elixir) is a far riskier choice than people believe. Having a poor lib ecosystem is being a victim of software poverty and you'll only measure how much you loose once it is too late. Kotlin ability to idiomaticaly reuse the multi billions of value JVM ecosystem make this language outclass all others "modern languages" The only other modern language as good at reusing a complete, battle tested ecosystem is, to my knowledge, typescript.

Others are condemned to perpetually reinvent the wheel instead of making true progress.

For the love of christ please learn some object oriented programming or invent something using which you can write more than 100 lines of code which does more than solving a leetcode problem.