markdown guide
 

Here's my example :)

I've been programming for 10 years, and I began with Java. After 2 and a half years of it, I've made the switch to Ruby. At the time, I've thought on the following points:

  • Readability
  • Available libraries
  • OpenSource community
  • Local community (more active and less "enterprisy")
  • Community philosophies
    • Tests were important and even small libraries wrote specs
    • Code quality and readability was praised and shared

Beginning

I was curious about the web. I wanted to know how the internet really worked out and was built, so I began studying HTML, CSS, JS and PHP. After a while, I got an opportunity on professionally working with web Java as a company intern.

At the time, I only knew a bit of "Wordpress", and didn't like PHP at all (syntax and local community). It simply didn't attract me.

Working with Java

When I got the job as an intern, I started working with a web framework they came up with, but was happy with it as I could see how the server-side really behaved, applications got deployed and learned a lot with their devops.

After a while...

Almost two years after I got in the company, my interest faded away, as I saw new technologies popping up and solving problems in a easier way. I've met Ruby on Rails through a college friend and it was wonderful.

At the time, Java also had Grails, but it didn't caught my attention. Groovy had a funky syntax, and a simple scaffold didn't work out of the box (with me, at the time, probably not doing it correctly and not having help around :P).

The Java IDE (Eclipse) we used was irritating me more and more. (Note: the company required that all devs used the same IDE).

Lastly, I wasn't happy at all with its ecosystem. IDEs were clunky, libraries didn't have a pattern and everybody I've met wanted to reinvent the wheel.

Also, around 2008/2009, Stack Overflow just had appeared, and Java threads always seemed to end in flame wars instead of actually solving problems.

Switching to Ruby

After some thought, I've decided to seriously focus on Ruby. Got some books, tutorials (Railscasts was incredible at the time!), started some basic Rails projects, and ended up using it to build my college's final project.

The problem was, I couldn't use it professionally. If I was going to use it, I had to quit my job and search for a company that used Ruby.

I ended up quitting the Java job, since at the time, I could do it. I had the wonderful opportunity on being jobless for a couple of months until I found something else.

Nowadays

Ever since, Ruby has been my main programming language (quick scripts, life automation, professionally, etc).

Nowadays, the web is a very different world! :) and I've been thinking on seriously studying Elixir.

 

I'm also a Java -> Ruby convert. My story was learning Java in university, but I dropped out of CS after 1.5 years and feeling like it wasn't for me. A couple years later, still with an interest in technology and a few failed attempts at scrapping things together with help and still feeling helpless, I wanted to get back into code for real. I had an idea in mind and someone recommended Ruby on Rails as a good approach. He didn't know all that much more than me, but he knew where to look.

So when I got into Ruby I felt a lot more comfortable. The friendly syntax and flexible standard library really make coding a breeze. Ruby can be frustrating when you write a bug that Java's compiler would have caught, but it's an environment that lets me go from concept to execution without losing my train of thought.

I still mostly write in Ruby, but consider myself someone who'd "pick the right tool for the job". It just so happens that the right tool has remained Ruby. I was working on a node project for a while and was way less happy.

My current project, dev.to is a Rails app, but I am prepared to evolve it into a multi-language project via services and/or interop, like with Rust but for now, that's overthinking the problem at the present. For now it's just a basic Rails 5.1 app.

 

The short answer is: At first, because the job required it. After that, it was to searching for something which would help me to stop making spaghetti messes. Unfortunately, language alone can't accomplish this, but it can help.

I'm old

The first language I did professional work in was PHP 3 or 4. (Not counting Pascal, C, C++ projects in college.) The very first one was because I didn't have enough to do as IT support, and I expressed an interest. I think I picked PHP because it was easy to get into and considered a beginner-friendly language for web programming. At least half of the PHP apps I wrote during this period are still in use today. (Oh the horror!)

Paying the Bills

Then I got some contract work to integrate with a VB6 system, so after some research, VB and C# on .NET seemed like the obvious choices. So I learned them for the job. For a while after that, most of my career was in C#, eventually wandering into Javascript front-ends as JS became powerful enough to make that happen. (And because it's the only choice for apps that run in browser.)

Learning FP

I still was not happy with the maintainability of the solutions I was coming up with. So I started searching for other languages, tools, patterns, ...anything. I played with F# briefly, but found it weird and put it back on the shelf. Eventually I came back and started doing some coding in it... sortof awkward hybrids of procedural code and functional trappings. But eventually, I got attuned to the functional paradigm and I love it. I feel like F# is the hidden jewel of the .NET framework. I have trouble finding a similarly well-balanced language as F# on other platforms. I use Elm on the front-end, which is similar but is not a general purpose language. I'm interested to learn Rust for a low-level project as it seems to be in the same vein as well.

But in the end...

I think if I had learned "pure OO", I might have also been happy with C#. But as it was, I thought I already knew OO programming and was disappointed with it. Turns out that just following patterns of a language doesn't work nearly as well as following the philosophy of the paradigm you're writing in. That's one of the reasons I love this post.

 

So as a relatively new dev, I got my feet wet in Node. Which I'm thankful for—I probably would have never even considered programming as a career option without the ecosystem that developed around it.

But a while back, I realized that I wasn't actually growing as a programmer much, just getting better and better at searching npm and find the right module to do what I wanted. So I decided to take a step back and learn another language, one with fewer existing modules, in order to force myself to write the code for myself, with the additional goal of moving in a more functional direction.

I ended up going with Reason/OCaml, in part because of the great support I saw coming from that community, and the inherent benefits of a statically + soundly typed language. Plus the escape hatch of always being able to compile to/interop with JS if I absolutely needed to.

I've written a couple of little CLI apps with it, hopefully putting the first one out in the public this week, and starting to convert my React Native project to Reason-React. And I can honestly say that I've learned more in the past 3-4 months than I have in the previous year. So far, so good!

 

Beginning
I started with C# .NET on my university but I didn't like to develop only for windows environment. Also I was interested on building applications on the web. So I met PHP and I didn't like the syntax and also the available frameworks.

Switched to Ruby
A year after that I met Ruby on Treehouse website and I loved it, I was so clear and easy to use that I started to build applications really fast because of its simplicity and also the huge quantity of open source projects. So I have been working with ruby since that time, building bigger and bigger platforms.

Trying languages and frameworks
Two years ago I saw how node.js grew up and when I tried I had to install too much dependencies to build simply things also node.js uses a lot of memory and processor. Couple of months after that i met elixir and using it I understood that its too different of ruby because it's a functional language but i still liked.

The new way
On the last six months i met Crystal and i really liked, it's pretty fast, as clear to write as Ruby, concurrency and parallelism(on development) are simply to use and uses low memory and processor. Nevertheless, the problem is that Crystal nowadays is on alpha and the are only few open source projects.

So i think im going to contribute to Crystal and Crystal open source projects.

 

Mostly what made me switch was driven by what my employer wanted me to do.

So over time my main programming language went through (ignoring recidivism duplicates)...

  • BASIC
  • Assembly
  • C
  • C++
  • Objective-C
  • C#
  • TypeScript

For fun, I've also significantly used Python, Swift, F#, D, Lua.

Also for fun and/or job related, I've worked with many different languages at least a little bit. Pascal, Object Pascal / Delphi, Perl, LISP, Scheme, FORTRAN, SmallTalk, Squeak, REXX, Rust, Ruby, JavaScript ES6, CoffeeScript, Elm, GorillaScript, MATLAB, Transact-SQL, Awk, Prolog, and probably a lot more that I've forgotten about.

Usually a critical factor is that certain languages are the premier language for a given platform. So if I am working on the JVM platform, Java is a likely "must learn" language even if the project were Clojure or Scala based (I haven't learned those yet, but they're in my queue). Or if my platform is iOS, then Objective-C and now Swift are the "must learn" languages.

 
 

I went from Java to Kotlin to Go.

At first I learned Java, mainly because I was 12 and I played Minecraft. I was really bad at programming at first, but given a few years of self-taught programming I got better.
A couple years ago I learned Kotlin. It was such a huge improvement over Java, and I loved it. My only real issue with Kotlin was that it was extremely high level, and there were 10 different ways to do the same thing, making it hard to work together in teams with it.
Then I discovered Go. Go is a really nice mix between high and low level. Go is lower-level in that it gives you access to things like pointers, fixed-length arrays, etc, but it’s also high-level in that it has GC, structural interfaces, goroutines, and channels. It also is very faithful to being a structural language, and not be object-oriented or functional.

 

I consider OCaml to be my 'main' programming language nowadays. I switched from Scala because of compile times and a more elegant type system. Compile times are a bit of a pet peeve of mine with every compiled language :-) Maybe I'll try out D next, I heard it has great compile performance.

 

I will still be writing JavaScript on the frontend, but I switched over to Go on the backend. The reason was Node; all APIs still using callbacks while all the people are using promises. And now the .mjs extension thing... 🙄
That, sumed to the fact that I wanted to try Go.
I heard a lot about the h2 implementation of Go and how speedy it was, so I gave it a try and I love the language now 😍 So much nicer to work with.

 

I made the switch from PHP to Node.js recently due to a few reasons.

When I started with PHP it felt amazing, I could code on my server and the changes would be applied instantly (ikr, really great idea, editing prod code). I owe my love of coding to PHP because the barrier to entry is so low and it really got me hooked. I wrote my first small-scale app in PHP and I had no idea what a framework was back then, so I wrote classes for the database 'entities' (now we call them models). The app became a pain to maintain and I had zero test coverage.

It was around this time that someone introduced me to Node.js. I thought it was a bit of a toy really, for the cool kids. I kept going with PHP for a bit longer and then out of the blue I discovered Mongoose (an ORM for Node & MongoDB). Wow. That was cool. I could define all these methods and validations and all sorts of funky things on models and I thought this was super awesome. No dirty data in my database! The idea of an ORM was something I had never come across before and so I was absolutely hooked on it. Remember that PHP app I was developing? I threw it out and rebuilt it with Node and Mongoose. I'm still developing it now and I've learnt a lot along the way about CI/CD, testing, all that kind of stuff. And I love it.

Recently though, I've been doing some Rails for a client project. It was really comforting to come to an MVC-based framework because it meant I had a good understanding of how it all fitted together. Then it was just a matter of learning Ruby (basically, just write plain English). I've been blown away by how well thought-out Rails is and things like rspec, capybara etc are things I've come to love. I'm still very much a novice on the Rails front, but I know the basics.

When I come back to my Node app, I really miss having a well-designed test suite (mocha is okay, but it pales into comparison compared to rspec). What I do not miss though, is migrations. Urgh. Rails does an excellent job of dealing with that for you, but I still don't like having to restructure the DB now and then. It's not fair to blame that on Rails though, that's just how structured/relational databases work. Another thing I love about Rails is being able to do very advanced model associations like HABTM, which with mongoose is a pain to implement. All those .populate()s! I'm not going to go on a callback rant because, well, I'd probably fail silently.

So, I'm now at the point where I know Express & Mongoose inside out and back to front, but Rails is coming up fast behind them. I'm not entirely sure what to focus more time on, getting Rails up to speed or bashing out more JS. Rails is far more adopted, but I've got this feeling that Node is going to start to become more widespread, even if it's got some serious design problems to overcome first (yeah I'm talking about you, promises/callbacks/ORMs).

Another lang on my radar is Go, so maybe I'll give that a serious try at some point.

 

Wow, I seem to have gotten to the party a lot earlier than everyone else so far... I started at the tail end of the "build it yourself with a soldering iron" phase. My first language was BASIC and from there I moved on to 6809 and Z80 assembler while still interfacing with hardware and making my own boards. After college I actively programmed in BASIC, COBOL, DYL-280, Prolog with a lot of funky scripting langages (NCR ITX, DOS) for a number of years. After that we moved into 4GLs at work, so I was developing using Foxpro, VB and Progress with some COBOL in the middle. I finally made it into the "real" world of programming when I started with Java 1.0 in the early 90's, what a wonderful language that was where the compiler would actually tell you more than "you spelled something wrong". I have been working in Java since then and have added C#, C, and Ruby.

My main factors in learning new languages (current total is 30 languages) is the desire to do something better/faster/easier than whatever I was working with, but in most cases it was my work changing to go in different directions. I started with Web programming in the late 90's using Java/JSPs and simple HTML (cursing that you couldn't even depend upon there being JavaScript on the browser back then). JS has only gotten better and better since that point, such that I like it a lot for many small tasks that need a UI. I find it amazing that I can now slap together a simple application in JS/HTML/CSS with a trivial backend in any one of Java or Ruby and have it fully functional in 1 day or less. This was unheard of for me in the early 90's where a GUI alone took a week.

With the new libraries and frameworks coming out fast and furious it's now almost impossible to work on anything using "current" technology. In most cases I live with "newish" technology using something that's 1-2 years old.

One useful tidbit that becomes obvious after you learn a bunch of languages is: Language syntax is the easiest thing to learn, it's the libraries that will kill you.

 

One useful tidbit that becomes obvious after you learn a bunch of languages is: Language syntax is the easiest thing to learn, it's the libraries that will kill you.

👏 Bravo! 👏 Will keep this in mind for the rest of my dev life!

 

How I started

I started coding in High-School. Back-then, LAMP stack was the easiest to get started, and also really famous. I ran PHP with no framework, then I discovered the micro-framework atomik then Code-Igniter.

University

In my first couple of years of university, we learnt C and C++ to work on low-level programming, I did few internships in PHP afterwards. In 2014 I heard about Node.JS and got really excited about it, back then it was hard to find good resources to get started with. It got easier and I was really comfortable with it, as I already knew Javascript fairly well.

Python time
At the end of my bachelor (2016), I had the chance to do an internship in a Dutch start-up (which I'm still working as employee now). I worked on a project built with Django framework, which was somewhat challenging to learn because the existing codebase was kind of messy. I really love Python and Django and wish I discovered earlier. It's has a perfect readability, a great community, and it's a very mature language/framework. I realized that working on a project in Node.Js was really hard to maintain and scale, and it always seems hacky.

 

Before even going to university and while in it I learned lot of languages. On my own or on courses. I did things like games, a very basic 3D rendering engine, some graphical tool to morph images...

Now I work in Java and I would say that in a sence, yes I work in the language my employer pay me for. I want to create things and to create interresting things. When I already worked a lot on that during the day, searched the internet already to read how to better solve my employer problem, I don't have the will to do that on my own for a pet project.

In the past few years I got the opportunity to be the technical leader and architect of a new key product for the company. The business domain is interresting, the technical problems to solve too. The scalability and performance requirement a challenge. Our first client ask for 6000 TPS. If the product is a success it will be deployed worldwide and I would not be surprised if it would be used one day at 100K tps on quite a few farms.

Learning a new language is fun and I pushed for scala, I used clojure a bit for myself but the problem of the language is that they are barely used. Scala a bit more with big data and in the finance sector but that's about it.

I want to create, I want to take challenges. A great developper can be a great developper in any language and he can learn and help colleagues in any language. But the interresting projects, are where they are.

I don't want to pick a random language or technology and be happy because it can do CRUD in a few lines of codes. PHP does it in one line and the performance and scalability is far from bad. When you need something scalable and complex, likely that you can't afford most of the more exotic choices.

They either miss the performance, the libraries or the workforce and basically that's part of why they are not more used.

This is a chiken and egg problem and I would love to switch to scala or why not haskell but this isn't that easy.

I'll push for it but the project has to be great first. The technology behind come second. And well with Java8 we start to have something decent. Not great as a language with many quirks and limitations but it is a robust tool.

 

Search for FOSS which uses Object-Pascal and is of any importance to next-gen technology. Then search for developers who would love to contribute to your Object-Pascal application as a hobby.

To make it short, imho, there is no big community and they struggle to interface with libraries written in C in order to not fall behind everyone else. While they do, they have difficulties to develop the next big thing in their own language.

Embarcadero monetizing the hell out of Delphi didn't help either. So, imho, while Object Pascal is a nice language and I still see some Russian black-hats write applications in it, I don't think it has any future.

I decided to go all full-stack dev, then, so the first big change was to JS/PHP (and C++ on the game site).

Lately, however, I am about to change the language for my hobbies, again. This time for performance, but mainly stability reasons. The language I want to change to this time is Rust. While the borrow-checker hates me and lifetimes bully me, I still love all those concepts which lead to very solid applications while being zero-overhead at the same time :)

The Rust ecosystem already has awesome crates for webserver development, and adding V8 for little Javascript parts (no way around little scripts, ever^^) gives me the ultimate freedom. Since Rust is directly comparable to C++, it also helps me create games, so instead of honing my skills in different languages, just using Rust is a lot easier!

Well, if you are interested in the professional languages I use... I change them based on what I need and what my boss tells me to use (though I never fail to at least voice my opinion)

 

I work with the web for more than 22 years and my first server-side language was Perl. Sadly Perl lost a lot of market shares and job offers started to dwindle.

At the time PHP was starting to rise in popularity and it brought a lot of perl-like syntax and concepts along, so I've naturally switched to it. Been working with PHP for more than 17 years now and I personally love it.

 

Ooh story time!

I've been doing this professionally for over a decade now (yep, I'm old, get off my LAN!).

I started with VB.NET and quickly jumped into C#.

C# and web development ASP.NET have been great to me all these years. I can't complain. But I think it's time to see other languages or think in different paradigms. This explains my reasoning/research into functional programming over the last 2 years.

Over the years

  • Ruby
  • Python
  • F#
  • Elm
  • JavaScript (of course)

Lesser extend

  • Clojure
  • Scala
  • Haskell (this one scared me, I'm not worthy, I'm not worthy!)

Today

I'm still doing C# and .NET to pay the bills. I've been having a tough transition from C# to JavaScript. It's harder when you are branded as "back end developer" now-a-days.

This is why I have double down on JavaScript via React. I've talked to plenty ex-.NET developers who've made the transition to more front-end development. They are my inspiration in the dark times when my mind tells me I'm nothing more than a back end dev.

Future

Ideally, I'd love to work full time in FP regardless of language. I'm using JavaScript as my language/syntax but using the FP paradigm. React scratches that itch really well.

As I said, I've done imperative for over a decade and needed a change. FP gives me that huge change and has re-kindle my love/hate with programming.

Newbies devs

It's true. Once you learn your first language/syntax, the next one becomes easier. But the pain cannot be avoided.

You cannot teach experience, you must go thru with it.

  • Albert Camus
 

First I have to say I don't have a real 'main' programming language; I've been exposed to programming since I was about 9 years old and I am often constrained to certain languages because they either come with the target platform or because the customer already has a working system for me to help with or take over.

That being said, my biggest professional projects were in C# and Java and I quickly came to love Groovy as a nicer way to write Java. I always liked C#, but as far as the community was concerned, the Java side was much better - nicer and more engaged people, better answers to my questions etc. The documentation and tooling is also better on the Java side IMHO so for a long time I considered Groovy to be my 'main' language. That, and by necessity Javascript, though I never had much love for it.

Then Kotlin came along and it was love at first sight. It was as if someone took the best things from C# and Groovy and fused them into a single language (and since Kotlin comes from people deeply involved with both Java and C#, I suppose it's no wonder). It has both static typing (which I love in any non-trivial project) as well as a compact syntax without relying on "magic" as Groovy or Ruby often do. IntelliJ IDEA has first class support for the language and most of Java's tooling can be used, together with its rich selection of libraries - and many Java libraries have started supporting Kotlin because it's very simple to (e.g. you can simply add a couple of methods to make Kotlin usage much nicer and while you can achieve that with Kotlin's extension methods without help from library authors, having it already done for you is the cherry on the cake).

For those parts of a project that benefit from a more dynamic language, I can still use Groovy alongside Kotlin with ease and sometimes I even paste a .java file in there, especially for code I pilfer from Stack Overflow :P

Kotlin's recent adventures in cross-platform land excite me also, primarily as a way to share "background" code between our Android and iOS apps (I'm primarily a backend developer, but with Kotlin I could also write parts that interact with the server and leave the frontend to our specialists).

So while I still program in other languages, give a free choice and if it fit the requirements, I would choose Kotlin today to start a new project in.

 

I still prototype in Ruby and other dynamic languages but I understand now why dynamic languages don't scale so for all production systems I prefer something with a static type system.

Dynamic languages are wasteful in terms of resource utilization and onramp time for developers new to the codebase. Basically any dynamic codebase beyond a certain size becomes unmaintainable in a team setting. Code is more often read and modified than written from scratch so a good type system goes a long way in minimizing the overhead in those activities.

 

At first, I mostly did my projects in c++ or Java, mostly because they're common beginner languages and as such, I ended up finding them when back when I was first learning to program. They worked for pretty much all of the small projects I did, so I very rarely poked into other languages.

Eventually, I started work on my biggest project, a web app for my robotics club. At first, I made it with Java, Spring, JDO, etc. I'd heard good things about Spring, but eventually, I found myself throwing hours and hours at the project and making almost no appreciable progress. The language, the framework, JDO were all working against each other and had their individual issues.

I'm not sure whether I'd learned this before or after searching for alternatives to Spring, but I'd heard that LinkedIn had had good experiences with Scala and Play. I'd heard of Scala before, and looking into Play I found a lot of people moving from Spring to Play, so I tried the duo and pretty much instantly fell in love. Scala definitely learned from the issues with Java, and Play's design worked spectacularly with Scala. I was able to remake what I'd spent a couple hundred hours making in a couple weeks, and progress has been orders of magnitude faster since. I definitely see myself using Scala in future projects whenever possible.

 

Rust replaced all of them pragmatically. I used to be split between C, OCaml, and Python for different projects. Now I just use Rust and sometimes Python for small scripts.

 
Classic DEV Post from Jun 19

How important are math skills for software development?

Tiago Padrela Amaro profile image
Web developer, geek and coder from Rio de Janeiro

Sore eyes?

dev.to now has dark mode.

Go to the "misc" section of your settings and select night theme ❤️