Need advice about which tool to choose?Ask the StackShare community!
Go vs Julia: What are the differences?
What is Go? An open source programming language that makes it easy to build simple, reliable, and efficient software. Go is expressive, concise, clean, and efficient. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines, while its novel type system enables flexible and modular program construction. Go compiles quickly to machine code yet has the convenience of garbage collection and the power of run-time reflection. It's a fast, statically typed, compiled language that feels like a dynamically typed, interpreted language.
What is Julia? A high-level, high-performance dynamic programming language for technical computing. Julia is a high-level, high-performance dynamic programming language for technical computing, with syntax that is familiar to users of other technical computing environments. It provides a sophisticated compiler, distributed parallel execution, numerical accuracy, and an extensive mathematical function library.
Go and Julia belong to "Languages" category of the tech stack.
"High-performance" is the primary reason why developers consider Go over the competitors, whereas "Lisp-like Macros" was stated as the key factor in picking Julia.
Go and Julia are both open source tools. It seems that Go with 60.4K GitHub stars and 8.36K forks on GitHub has more adoption than Julia with 22.7K GitHub stars and 3.43K GitHub forks.
Uber Technologies, Google, and Medium are some of the popular companies that use Go, whereas Julia is used by inFeedo, Platform Project, and N26. Go has a broader approval, being mentioned in 901 company stacks & 606 developers stacks; compared to Julia, which is listed in 5 company stacks and 5 developer stacks.
My name is Brayden. I’m currently a Frontend React Developer, striving to move into Fullstack so I can expand my knowledge.
For my main backend language, I am deciding between Python, Rust, and Go. I’ve tried each of them out for about an hour and currently, I like Python and Rust the most. However, I’m not sure if I’m missing out on something!
If anyone has advice on these technologies, I’d love to hear it!
Rust is still in low demand. It's a great language but you'll have a hard time finding jobs. Go is the mix of both Rust and Python. Great language with modern features, fast, scalable, fun to write, and at the same time it has high demand (not as much as python).
Python on the other hand is a language that you can't go wrong with. Look around you and see what your job market prefers. If there isn't much difference to you personally, pick the one with more demand.
All of these are solid options, however considering your expertise currently, I would probably suggest Node.JS considering your past experience with JS. However Python offers a similar development environment to JS in my opinion, and Go is a good sort of intermediate between Rust and Node.JS and Python. It's fast, but not as fast as Rust, and offers a development experience that combines C-styled languages (like Rust), and Python-y languages... So: Rust for the fastest, Node for familiarity, Python for ease of development, and Go for a good middle ground. I have used all in personal projects... If you use Go, I suggest a easy to use web server framework like Fiber.
Rust is a challenging choice, but worth to be chosen. It has strong memory-safety and type-safety, this gives you no bother about those errors. However, static typing languages often slow our developing speed down in early stage. In that case, it's effective to write prototype in an easy language like Python, and rewrite it in a hard language. It's important not to be afraid to throw away first code you write.
The other answers are excellent, but I want to be a bit of a contrarian and say you should learn Rust. While the number of jobs for it are (relatively) low(er), it is certainly expanding and you'd be surprised at which companies do use Rust (Discord, for example, is starting to move away from Golang to Rust!).
But the main reason is that learning Rust itself will teach you a lot about systems design (/backend) because of its borrow checker. You can try out a lot of ideas and make a lot mistakes and the borrow checker will always be there guide you to a better solution (thereby teaching you in the process).
Also, I wouldn't underestimated how important managing memory (and memory safety) is. While Golang is great in some ways, it doesn't protect you from pushing memory leaks into production. And eventually you'll come upon a scenario where you'll have to make your Python code run faster and the optimizations you'd have to do won't look pretty (or be very Pythontic).
And Rust is freakin fast! If you have Rust, you wouldn't need any other language for the backend (or any other systems level code). Check this blog post: https://blog.discord.com/why-discord-is-switching-from-go-to-rust-a190bbca2b1f?gi=dd8bc5d669d. Discord found that even after spending months optimizing Golang code it still wasn't fast enough. But unoptimized, first-draft Rust code was (is) faster by an order of magnitude!
I want to build a tool to check asset availability (video, images, etc.) from third-party vendors. These vendors have APIs. However, this process should run daily basis and update the database with the status. This is a kind of separate process. I need to know what will be the good approach and technology for this?
for what technologies you should use, this is depend on what technology do you prefer? your should think best structuing for your code because each API vendor has different to a nother one so it's better no merege code vendores together. your code must be using SOLID principle pattern and some design pattern such as Factory Pattern
The major advantage of Go is that you can run queries in parallel. Fire off a Go thread for each vendor and each thread can check the availability of assets from a specific vendor and update the database. Go supports hundreds of threads with ease.
your decision depend on what language do you know. if you know php you can use laravel framework
Hi, I would recommend Go because of strongly-typed nature which makes a developer more productive as it is less error prone compared to the other dynamic-typed language. Go also has cron-job library(powered by goroutines) that can help with your automated tasks.
I am a beginner, and I am totally confused, which of these 3 languages to learn first. Go, Rust, or Python. As my studies are going which of them will be easy to learn with studies that is, I can learn and do my studies also. Which one of them will be easily handled with my studies, and will be much much useful in future?
python is a good language to start for the beginner.
Python is a great language to learn as a beginner. However, Go is really easy to learn as well and has a much more powerful standard library that will allow you to build very complex and powerful applications in the future. Go is becoming a standard in Cloud computing and concurrency. Both of which are very advanced but important.
I have experience in all three languages, and you should learn python first. These are three different languages (read: tools) to solve different problems you may have. Python is a high level language you can use for writing cross-platform scripts, web servers, AI, websites (e.g. Django) and the list goes on. Python can be used for most programming tasks while being the easiest to learn of the three and probably the most productive as well.
A lot of tech companies start out with Python for their web services, but due to Pythons slow speed and the pain that comes with dynamically typed languages when the code base grows, switch to Go later on when they need to scale. Go is a systems language that thrives when used for high performance cloud/web or networking services. Go is used in performance critical networking situations such as Twitch's streaming services and Uber's geofence services. It's also very clean and simple syntax that makes it very easy to quickly understand what code does.
Python is an interpreted language and Go is a garbage collected language, but Rust is a highly performant and reliable compiled programming language without the extra baggage of runtime memory management. Rust forces you to follow coding patterns that assure memory safety. This makes Rust a perfect fit for high performance algorithms, game engines or safety-critical systems, but would be overkill for web servers or scripts on modern hardware.
I'd definitely start with Go. I know Python, Go and quite a few other languages.
Rust is not easy to learn as a beginner.
Python has way too many features to be called "easy" to learn. While it is very forgiving to beginner mistakes it feels like playing in a puddle of mud. It does not teach you clean programming at all. Unless of course you like messy.
Go on the other hand is very easy to learn. As a professional you can learn the entire language in under 2 hours. I have already given the tour of Go (https://tour.golang.org/) to complete beginners and they went through it very thoroughly and thereby knew the entire Go language in less than 5 days. While it is very easy to learn and very easy to read, it is quite strict on other things, guiding you to write clean code. For one it is a typed language and it is good to learn very early about types.
Knowing the entire language is of course not all there is to know. There is the standard library and a lot of other libraries to get to know in every language. Also one has to learn patterns in every language, get experience on how to structure code, dig deeper into the language itself to understand its inner workings, etc. That takes years in every language.
That being said, it depends very much on what you want to do with a language. If you want to go into ML and science you definitely need Python. If you want to go into cloud computing, distributed servers (which in my opinion any server should be nowadays), use Go. If you want to do systems level programming, e.g in hardware programming, use Rust.
If all you want is a gentle intro and have access to tools and libs that can help with your tasks, Python is the way to go. It's ecosystem is huge and the language is easy to pick up. However, if you are aiming to get into software industry, I'd highly recommend you also pick up another classic language like C++/C#/Java. It really helps you cement some CS & programming fundamentals and get more familiar with the concept of software design and software architecture. Not saying you cannot achieve good architecture in Python or Go, but traditionally you have more materials covering these classic OOP languages. And once you learn them, you can apply your knowledge to other languages and it helps you understand other languages faster.
Rust is probably a bad choice for starting out. It is a low level language where garbage collection is not done automatically, and has to get you thinking about all the technical aspects. It is statically typed and compiled, so it's very strict with how you code. I do love Rust though, it's a nice language. Golang is also compiled and statically typed, but it aims to be for quick development, which makes it a better choice for starting out.
If you start learning programming I'd suggest Python language. I have no experience with Go and Rust so I cannot give you advice for them.
Python has the broadest reach as it's been around the longest; rust is much more difficult for a beginner to learn; I work with Go every day and it's probably the most productive general use language.
Learn/start with C; don't rush after buzz words. Python is easy to learn but you would not get the underpinnings of memory and pointers, an important aspect of programming.
I'd choose python because with a good knowledge of python and it's libraries, you could do literally anything. Also it has a relatively simple structure, so it won't be tough for a beginner.
Later on if you wish to learn Rust and Go, please do by all means.
Python is the best programming language for starting out as it is quite easy to learn, but it also is very powerful and you can do plenty with it. It will be useful for a long time. Python is my recommendation.
Go and Python are going to be much easier to learn than Rust. The memory management for Rust is pretty hard to wrap your head around when you are first learning how to do basic things with the language. Get familiar with programming first, then learn Rust.
Study, machine learning = Python | High performance computing, safety-oriented programming = Rust | Backend, feel productive with less runtime performance drawback = Go
Python is a great language to start programming with, there is an awesome python course on coursera by Dr. Charles Severance called Programming for everybody, check it out :)
Python, because its the easiest to learn as a beginer. Its often called "English without grammar" because its terms and writing style is quite similar to English. Python also has a diverse range of applications like Web App, Desktop App, Data Science etc
Python is the easiest of the languages to learn, and while the slowest in production, it will teach many of the basic fundamental concepts of programming, especially if you're not going to be doing anything low level or at a system level.
I agree with most of the other answers here. Python is the best choice because it is super user-friendly, has an easy syntax, and can do many complex things in relatively fewer lines.
While Rust is a more recent and a great language nonetheless, it is slightly more complicated as it involves compiling and the syntax isn't so great.
And Go is the not a great choice either. While it has a decent syntax, keep in mind that Go won't be of much use unless you plan on working in Google. Even if you want to learn it, you can do so later.
I hope this helped you in making your decision, and welcome to the world of programming! I hope you enjoy.
I need some advice to choose a language for back-end development. Right now, my REST APIs were created by using Flask/Django, and I'd like to create a more reliable and more efficient API with static typing. On the one hand, Go is young, very light, and syntax like Python's, but C# has a large number of libs and more built-in methods. Which is the best solution today?
From times to times I asked or was asked that same question. Technology aside, it's important to consider the skills and expertise that the dev team has. Whether you use language A,B or C or framework X,Y and Z, if your team has a strong background and experience with something make it count too.
I would recommend Go simply because as you mentioned, it's super light. No need to bring in the whole .NET suite to get a simple REST API up and running. Even if your API is a bit complex, Go should be able to handle it.
I'm new to Go, I've got very little experience but the 'feel' of Go, isn't like Python in my opinion. Go has a pretty steep learning curve, much steeper than C# in my opinion. So if you are willing to consider Node/Express/TypeScript, I think you may really like it. If you're picking between Go and C#, I'd go for C# as of today, but once I am more comfortable with Go (which I anticipate being a slow process) I may change my mind.
At this moment in time, in late 2020- Node/Express/TypeScript feels like the obvious choice to me as a former C# developer.
The best language for you is the one that you know best!
Its a bit of a guess, but from your question and the difficulties you have with Python it seems to me the problem you describe is the manifestation of a bad design/architecture/code quality. These are not the problems of a language itself!
The experience you gained over the past years with your current programming language will outmatch any benefits of another language that you start from zero.
Because in the end of the day languages aren't all that different when it comes to fullfil the same task, it's more the tools, framework and ecosystem for a particular problem that make a difference.
I worked with Java, C#, Go and recently in Phyton, and I would choose Phyton over Go for WebApps, even I like compiled languages more. Go is a very simple language, I would even say maybe too simple. I can't stand all those go boilerplate if err checks, the broken filesystem, the date/time mess and many more things that aren't actually relevant for business application at all. Go has its advantages but not for WebApps.
Keep the lang and improve your skills and architecture you will benifit more from it than from a new language.
I recommend Go for backend. It's younger than C# doesn't mean it's not mature. It's already mature enough to be run on production. You can see there are already many companies in the world adopting Go as their backend business logic or tooling. I can name a few like Github, Shopify, uber, twitch, and many more. It's easier learning curve, low entry barrier, better performance than C#, better memory consumption than C#, since there's no VM/runtime needed. It's suitable for large scale system and large codebase for readibility and long maintainability. It's simpler than C# since no class, inheritance(this can cause hard to maintain software), exception, etc. You can still implement OO way in Go without those feature. Simple file structure, only main files and package files. It compiles to single binary and easy to deploy and work around it, unlike C# who compiled to IL and you need to wrap all those IL files to be run inside separated web server(even .Net/.Net Core platform provide built-in web server). For libs, don't worry, there are many open source libs you will found on Github and already adopted by many companies. Go is employed in personal, startup, even corporate level.
I suggest Go because it has a simple and clean ecosystem. The language is simple. You don’t need complex configs or installs either. You’ll be up and running very quickly. It doesn’t have as much as .NET but its standard library is more than sufficient for RESTful APIs. Concurrency is much, much easier too.
C# I’d definitely recommend later on. The .NET framework, especially core, is extremely powerful and there’s little you can’t build with it. Go won’t take you long to be productive with.
I have some systems on production using both languages. I tend to use golang if the API is small or medium size, but if I am going to build a large system definitively I use c#(asp netcore).
If you want to stick with python you may want to consider Fastapi. It uses Pydantic to give you strongly typed models and validation. It generates openapi docs for you out of the box. They have good documentation as well and they claim it is really fast.
The database your are going to connect and the needed libraries could decide. Because both are awesome languages.
I would recommend C#, particularly Simplify.Web web-framework. C# is easy to start with (especially .NET Core). Simplify.Web is also easy to start with, no extra setup required for simple API, but on the other hand you have power of C# and full control over your API with ability to extend.
I've been juggling with an app idea and am clueless about how to build it.
A little about the app:
- Social network type app ,
- Users can create different directories, in those directories post images and/or text that'll be shared on a public dashboard .
Directory creation is the main point of this app. Besides there'll be rooms(groups),chatting system, search operations similar to instagram,push notifications
I have two options:
- React Native, Python, AWS stack or
- Flutter, Go ( I don't know what stack or tools to use)
Hope that helps, and good luck with your project!
I'm typically agnostic when it comes to picking languages. Whatever gets the job done, but, in this case, to figure out what's involved with what you want to do, it's going to be much more than just picking programming languages for your client and backend interfaces.
So, I'm recommending you use Flutter+Firebase as a way to figure out what you need to get done. It supports both iOS and Android out of the box, introduces you to a bunch of components you will need to think about in the future (whether you stick with Firebase or not), and the key here, is that there are tons of articles, youtube videos, and other courses you can take to pick it up pretty quickly. You could even clone an Instagram knockoff from github. Guess what else, it's all free. You might not need to worry as much about the backend since there are client libraries for Flutter/Dart for Firebase.
Some might have different opinions, and like I said, I'm usually agnostic, but in this case, you have a lot to consider. Where are you going to store the data? Are people going to need to login? Will there but customized settings the will save even if I close the app? Yeah, that's just a few questions.
Those are just a few. Lots to consider, so if you want to get something in your hand as soon as possible, try a search for flutter + firebase + chat + Instagram or something like that and have a look.
The above listed tools will do the job, you just need to figure out your architecture(e.g models). How they will all connect. Then you can use a tool you are comfortable with to implement them.
If this is for learning about how to design the system, then pick the tools are you are confortable with.
Often times, I get stuck picking the tools (and trying to learn about them) vs actually trying to design the system itself.
If you are familiar with React (check out Expo) and Django then I would recommend going with that.
For deploying your backend, I would go with a provider like https://zeit.co/ that automates a whole bunch of deployment steps with their cli tools that you might have to do with AWS.
What you need to take a look at is Apache OpenMeetings. It already does what you want, it is open source and well documented and only requires that you design the UI and plumbing required to serve you application.
Let's select right tool you feel you are good at. And selecting tools are used by large community to solve your stuck if encounter
We are converting AWS Lambdas from Java due to excessive cold start times. Usage: These lambdas handle XML and JSON payloads, they use s3, API Gateway, RDS, DynamoDB, and external API's. Most of our developers are only experienced in java. These three languages (Go, Node.js, and Python) were discussed, but no consensus has been reached yet.
I've worked with all three of these languages and also with Java developers converting to these languages and far and away Go is the easier one to convert to. With the improved cold-start times and the ease of conversion for a Java developer, it is a no-brainer for me.
The hardest part of the conversion though is going to be the lack of traditional Classes so you have to be mindful of that, but Go Structs and interfaces tend to make up for what is lost there.
Full Disclosure: I'm a 95% Go convert (from Python) at this point in time.
Go would provide the easiest transition for Java programmers -- its IDE/tooling is second to none (just install Goland) and the deploy/distribution story is extremely clean and lends itself to work well in lambda: single, static binaries with quick startup. No need to set up a full environment or package dependencies on your lambda AMIs, just copy a file.
So I'd agree, on the strength of AWS Lambda support and the solid performance of Go, it seems like your best choice here for Lambdas (and I'm going to need to consider that myself going forward... pardon the pun).
Finding the best server-side tool for building a personal information organizer that focuses on performance, simplicity, and scalability.
performance and scalability get a prototype going fast by keeping codebase simple find hosting that is affordable and scales well (Java/Scala-based ones might not be affordable)
I've picked Node.js here but honestly it's a toss up between that and Go around this. It really depends on your background and skillset around "get something going fast" for one of these languages. Based on not knowing that I've suggested Node because it can be easier to prototype quickly and built right is performant enough. The scaffolding provided around Node.js services (Koa, Restify, NestJS) means you can get up and running pretty easily. It's important to note that the tooling surrounding this is good also, such as tracing, metrics et al (important when you're building production ready services).
You'll get more scalability and perf from go, but balancing them out I would say that you'll get pretty far with a well built Node.JS service (our entire site with over 1.5k requests/m scales easily and holds it's own with 4 pods in production.
Without knowing the scale you are building for and the systems you are using around it it's hard to say for certain this is the right route.
Go is a way faster than both Python and PHP, which is pretty understandable, but we were amazed at how good we adapted to use it. Go was a blessing for a team , since strict typing is making it very easy to develop and control everything inside team, so the quality was really good. We made huge leap forward in dev speed because of it.
Context: Writing an open source CLI tool.
Go and Rust over Python: Simple distribution.
With Go and Rust, just build statically compiled binaries and hand them out.
With Python, have people install with "pip install --user" and not finding the binaries :(.
Go and Rust over Python: Startup and runtime performance
Go and Rust over Python: No need to worry about which Python interpreter version is installed on the users' machines.
Go over Rust: Simplicity; Rust's memory management comes at a development / maintenance cost.
Go over Rust: Easier cross compiles from macOS to Linux.
We’re a new startup so we need to be able to deliver quick changes as we find our product market fit. We’ve also got to ensure that we’re moving money safely, and keeping perfect records. The technologies we’ve chosen mix mature but well maintained frameworks like Django, with modern web-first and api-first front ends like GraphQL, NextJS, and Chakra. We use a little Golang sparingly in our backend to ensure that when we interact with financial services, we do so with statically compiled, strongly typed, and strictly limited and reviewed code.
You can read all about it in our linked blog post.
As for why we didn't pick the other languages, most of it comes down to "personal preference" and historically grown code bases, but let's do some post-hoc deduction:
Go is a practical choice, reasonably easy to learn, but until we find performance issues with our NodeJS stack, there is simply no reason to switch. The benefits of using NodeJS so far outweigh those of picking Go. This might change in the future.
PHP is a language we're still using in big parts of our system, and are still sometimes writing new code in. Modern PHP has fixed some of its issues, and probably has the fastest development cycle time, but it suffers around modelling complex asynchronous tasks, and (on a personal note) lack of support for writing in a functional style.
We don't use Python, Elixir or Ruby, mostly because of personal preference and for historic reasons.
Rust, though I personally love and use it in my projects, would require us to specifically hire for that, as the learning curve is quite steep. Its web ecosystem is OK by now (see https://www.arewewebyet.org/), but in my opinion, it is still no where near that of the other web languages. In other words, we are not willing to pay the price for playing this innovation card.
Haskell, as with Rust, I personally adore, but is simply too esoteric for us. There are problem domains where it shines, ours is not one of them.
After writing a project in Julia we decided to stick with Kotlin. Julia is a nice language and has superb REPL support, but poor tooling and the lack of reproducibility of the program runs makes it too expensive to work with. Kotlin on the other hand now has nice Jupyter support, which mostly covers REPL requirements.
With Python + Django it was so much faster to create a typical website like this. Using Go would take to long to launch the initial version. For example, Python could handle complex data type with less line of code. Django also has many built-in libraries and a huge ecosystem of libraries that can be easily used to build a feature.
Telegram Messenger has frameworks for most known languages, which makes easier for anyone to integrate with them. I started with Golang and soon found that those frameworks are not up to date, not to mention my experience testing on Golang is also mixed due to how their testing tool works. The natural runner-up was JS, which I'm ditching in favor of TS to make a strongly typed code, proper tests and documentation for broader usage. TypeScript allows fast prototyping and can prevent problems during code phase, given that your IDE of choice has support for a language server, and build phase. Pairing it with lint tools also allows honing code before it even hits the repositories.
1. Type safety and inferred types
Go is type safe by default, which allows you to right more reliable code and have better developer tooling, plus with the
:= operator, you can initialize a variable without having to define its type because it automatically gets its type from the initial value.
There isn't much to be said here, but on most counts go beats both Python and Node.js on performance.
I'm not talking about the Go language itself, although it does have good docs. I'm talking about Go's auto generated documentation tool, which allows people to document their packages easily and works amazingly with Go's type system.
4. Compiles to binary
If you are making a local program for somebody and they don't want to download the Go compiler, you can make Go into a native binary.
5. Built for the web
Go has built in Http libraries to rival Express.js and has a HTML/Text templating system.
6. Great Concurrency
Go utilizes Goroutines to help developers utilize multiple threads easily.
Go is an excellent choice for any system code, especially http networking and web backends.
C# and .Net were obvious choices for us at LiveTiles given our investment in the Microsoft ecosystem. It enabled us to harness of the .Net framework to build ASP.Net MVC, WebAPI, and Serverless applications very easily. Coupled with the high productivity of Visual Studio, it's the native tongue of Microsoft technology.
Go was the other serious candidate, but it just hasn't been implemented in as many Production systems yet, and the best Go engineers I've known have been hackers, whereas we're building a robust analytics platform that requires more caution. Type safety is easily added with TypeScript, and NPM is awesomely handy.
Pros of Golang
- Simple, minimal syntax392
- Fun to write359
- Easy concurrency support via goroutines299
- Fast compilation times271
- Statically linked binaries that are simple to deploy179
- Simple compile build/run procedures150
- Backed by google136
- Great community134
- Garbage collection built-in52
- Built-in Testing45
- Excellent tools - gofmt, godoc etc43
- Elegant and concise like Python, fast like C39
- Awesome to Develop37
- Used for Docker26
- Flexible interface system25
- Deploy as executable24
- Great concurrency pattern24
- Open-source Integration20
- Easy to read17
- Fun to write and so many feature out of the box17
- Go is God16
- Its Simple and Heavy duty14
- Powerful and simple14
- Easy to deploy14
- Best language for concurrency13
- Rich standard library11
- Safe GOTOs11
- Clean code, high performance10
- Easy setup10
- Simplicity, Concurrency, Performance9
- High performance9
- Hassle free deployment8
- Single binary avoids library dependency issues8
- Simple, powerful, and great performance7
- Cross compiling7
- Used by Giants of the industry7
- Garbage Collection6
- Very sophisticated syntax5
- Excellent tooling5
- Keep it simple and stupid4
- Widely used4
- Kubernetes written on Go4
- No generics2
- Operator goto1
Pros of Julia
- Fast Performance and Easy Experimentation23
- Designed for parallelism and distributed computation21
- Free and Open Source17
- Multiple Dispatch16
- Dynamic Type System16
- Calling C functions directly16
- Lisp-like Macros16
- Powerful Shell-like Capabilities10
- Jupyter notebook integration9
- String handling4
- Emojis as variable names4
Sign up to add or upvote prosMake informed product decisions
Cons of Golang
- You waste time in plumbing code catching errors41
- Packages and their path dependencies are braindead23
- Dependency management when working on multiple projects15
- Google's documentations aren't beginer friendly15
- Automatic garbage collection overheads10
- Uncommon syntax8
- Type system is lacking (no generics, etc)6
- Collection framework is lacking (list, set, map)3
- Best programming language2
Cons of Julia
- Immature library management system5
- Slow program start4
- JIT compiler is very slow3
- Poor backwards compatibility3
- Bad tooling2
- No static compilation2
Sign up to add or upvote consMake informed product decisions
What is Golang?
What is Julia?
Need advice about which tool to choose?Ask the StackShare community!
Sign up to get full access to all the companiesMake informed product decisions
Sign up to get full access to all the tool integrationsMake informed product decisions