Go, also known as Golang, has faced criticism for several reasons, despite its popularity and strengths. Here are some of the main points of contention:
- Simplicity vs. Expressiveness:
- Go emphasizes simplicity and minimalism, which some developers appreciate. However, this can lead to a lack of expressiveness compared to more feature-rich languages. Critics argue that this can result in verbose code and boilerplate, making it harder to write complex applications. - Lack of Generics:
- Until the introduction of generics in Go 1.18, the language was criticized for not supporting generics, whi
Go, also known as Golang, has faced criticism for several reasons, despite its popularity and strengths. Here are some of the main points of contention:
- Simplicity vs. Expressiveness:
- Go emphasizes simplicity and minimalism, which some developers appreciate. However, this can lead to a lack of expressiveness compared to more feature-rich languages. Critics argue that this can result in verbose code and boilerplate, making it harder to write complex applications. - Lack of Generics:
- Until the introduction of generics in Go 1.18, the language was criticized for not supporting generics, which limited code reuse and type safety. Many developers found workarounds cumbersome, and the absence of generics was a significant drawback for those coming from languages that support them. - Error Handling:
- Go's approach to error handling, which requires explicit checks for errors after every operation, can lead to repetitive and verbose code. Some developers feel this makes the code harder to read and maintain compared to languages with exceptions or more advanced error-handling mechanisms. - Concurrency Model:
- While Go's goroutines and channels make concurrency easier to handle, some developers criticize the model for being too simplistic or not as powerful as those found in other languages. There are debates around the best practices for concurrency management, and some find the learning curve steep. - Standard Library Limitations:
- Although Go has a robust standard library, some developers feel that it lacks certain tools and features available in other languages, which can lead to reliance on third-party libraries that may not be as well-maintained. - Community and Ecosystem:
- The Go community has been criticized for being somewhat insular and resistant to changes that deviate from the language's philosophy. This can lead to a lack of innovative libraries and frameworks compared to ecosystems like those of JavaScript or Python. - Tooling and IDE Support:
- While Go has made significant strides in tooling, some developers feel that the IDE support and debugging tools are still not on par with other mature languages. This can hinder the development experience, especially for newcomers. - Performance Issues:
- Although Go is generally fast, certain performance bottlenecks (e.g., garbage collection) can lead to criticisms, especially when compared to lower-level languages like C or Rust, which provide more control over memory management.
Despite these criticisms, Go has a strong following due to its strengths in building scalable and efficient applications, particularly in cloud computing and microservices architectures. Many of its design choices prioritize simplicity, which aligns well with the needs of teams looking for maintainable codebases.
Go is designed to allow programmers to do programming easily and “get to work”, which is a good goal. However, just like you could either hire 10 people with shovels or 1 person with a bulldozer, shovel is easier to operate, yes, but it comes at a cost for those who know how to use a bulldozer.
And this is not another one defending inheritances/etc either. The problem lies with the lack of good generic and a good support for higher-order function with generic, which would allow things like map, fold, and so on.
With dynamically typed languages, these come easily. However, dynamic typing is gener
Go is designed to allow programmers to do programming easily and “get to work”, which is a good goal. However, just like you could either hire 10 people with shovels or 1 person with a bulldozer, shovel is easier to operate, yes, but it comes at a cost for those who know how to use a bulldozer.
And this is not another one defending inheritances/etc either. The problem lies with the lack of good generic and a good support for higher-order function with generic, which would allow things like map, fold, and so on.
With dynamically typed languages, these come easily. However, dynamic typing is generally slow. Pass a function into another function and it just works.
So, what should we do? My idea is to mimic dynamic typing with static typing or compile dynamically typed language to be fast using JIT/etc. Go doesn’t do either of that.
However, this is not a reason why. This is what I would do if I were given Go’s problem, to design a productive, simple, performant language. I would make a statically typed language that automatically templates all the function arguments to approximate python’s style function and perhaps do some attribute inference system to approximate python’s lack of need to declare struct memory layout.
However, this is in defense of dynamic typing, which is that it gives the user the ability to do generic, reusable code at any time. Or if I’d have to go with basic static typing with no extra feature, at least C-style macro would help, but go doesn’t have that either.
So, what happens? Well, you have a bunch of programmers who want all the fancy design patterns which actually are done for code reuse, who then complain about the lack of code reuse in GO. Then there are GO’s defender who like simplicity of GO. Then there is me, who is just like… wait… you can achieve code reuse and simplicity at the same time with dynamic typing or approximation thereof. So, it pisses me off, and it pisses off many programmers who love all the complex design patterns, who also piss me off.
Then there are safety concerned programmers who also hate GO for different reasons.
So, in conclusion, GO is a minimal language, so people who like any of the more advanced features of any programming language would hate it.
1. Overpaying on Auto Insurance
Believe it or not, the average American family still overspends by $461/year¹ on car insurance.
Sometimes it’s even worse: I switched carriers last year and saved literally $1,300/year.
Here’s how to quickly see how much you’re being overcharged (takes maybe a couple of minutes):
- Pull up Coverage.com – it’s a free site that will compare offers for you
- Answer the questions on the page
- It’ll spit out a bunch of insurance offers for you.
That’s literally it. You’ll likely save yourself a bunch of money.
2. Overlook how much you can save when shopping online
Many people over
1. Overpaying on Auto Insurance
Believe it or not, the average American family still overspends by $461/year¹ on car insurance.
Sometimes it’s even worse: I switched carriers last year and saved literally $1,300/year.
Here’s how to quickly see how much you’re being overcharged (takes maybe a couple of minutes):
- Pull up Coverage.com – it’s a free site that will compare offers for you
- Answer the questions on the page
- It’ll spit out a bunch of insurance offers for you.
That’s literally it. You’ll likely save yourself a bunch of money.
2. Overlook how much you can save when shopping online
Many people overpay when shopping online simply because price-checking across sites is time-consuming. Here is a free browser extension that can help you save money by automatically finding the better deals.
- Auto-apply coupon codes – This friendly browser add-on instantly applies any available valid coupon codes at checkout, helping you find better discounts without searching for codes.
- Compare prices across stores – If a better deal is found, it alerts you before you spend more than necessary.
Capital One Shopping users saved over $800 million in the past year, check out here if you are interested.
Disclosure: Capital One Shopping compensates us when you get the browser extension through our links.
3. Not Investing in Real Estate (Starting at Just $20)
Real estate has long been a favorite investment of the wealthy, but owning property has often felt out of reach for many—until now.
With platforms like Ark7, you can start investing in rental properties with as little as $20 per share.
- Hands-off management – Ark7 takes care of everything, from property upkeep to rent collection.
- Seamless experience – Their award-winning app makes investing easy and efficient.
- Consistent passive income – Rental profits are automatically deposited into your account every month.
Now, you can build your own real estate portfolio without needing a fortune. Ready to get started? Explore Ark7’s properties today.
4. Wasting Time on Unproductive Habits
As a rule of thumb, I’d ignore most sites that claim to pay for surveys, but a few legitimate ones actually offer decent payouts.
I usually use Survey Junkie. You basically just get paid to give your opinions on different products/services, etc. Perfect for multitasking while watching TV!
- Earn $100+ monthly – Complete just three surveys a day to reach $100 per month, or four or more to boost your earnings to $130.
- Millions Paid Out – Survey Junkie members earn over $55,000 daily, with total payouts exceeding $76 million.
- Join 20M+ Members – Be part of a thriving community of over 20 million people earning extra cash through surveys.
With over $1.6 million paid out monthly, Survey Junkie lets you turn spare time into extra cash. Sign up today and start earning from your opinions!
5. Paying off credit card debt on your own
If you have over $10,000 in credit cards - a debt relief program could help you lower your total debt by an average of 23%.
- Lower your total debt – National Debt Relief works with creditors to negotiate and settle your debt for less than you owe.
- One affordable monthly payment – Instead of managing multiple bills, consolidate your payments into one simple, structured plan.
- No upfront fees – You only pay once your debt is successfully reduced and settled, ensuring a risk-free way to tackle financial burdens.
Simple as that. You’ll likely end up paying less than you owed and could be debt free in 12-24 months. Here’s a link to National Debt Relief.
6. Overspending on Mortgages
Overpaying on your mortgage can cost you, but securing the best rate is easy with Bankrate’s Mortgage Comparison Tool.
- Compare Competitive Rates – Access top mortgage offers from trusted lenders.
- Personalized results – Get tailored recommendations based on your financial profile.
- Expert resources – Use calculators to estimate monthly payments and long-term savings.
Don’t let high rates limit your financial flexibility. Explore Bankrate’s Mortgage Comparison Tool today and find the right mortgage for your dream home!
7. Ignoring Home Equity
Your home can be one of your most valuable financial assets, yet many homeowners miss out on opportunities to leverage its equity. Bankrate’s Best Home Equity Options helps you find the right loan for renovations, debt consolidation, or unexpected expenses.
- Discover top home equity loans and HELOCs – Access competitive rates and terms tailored to your needs.
- Expert tools – Use calculators to estimate equity and project monthly payments.
- Guided decision-making – Get insights to maximize your home’s value while maintaining financial stability.
Don’t let your home’s value go untapped. Explore Bankrate’s Best Home Equity Options today and make your equity work for you!
8. Missing Out on Smart Investing
With countless options available, navigating investments can feel overwhelming. Bankrate’s Best Investing Options curates top-rated opportunities to help you grow your wealth with confidence.
- Compare investments – Explore stocks, ETFs, bonds, and more to build a diversified portfolio.
- Tailored insights – Get tailored advice to match your financial goals and risk tolerance.
- Maximize returns – Learn strategies to optimize investments and minimize risks.
Take control of your financial future. Explore Bankrate’s Best Investing Options today and start building a stronger portfolio today!
Disclaimer:
Found is a financial technology company, not a bank. Business banking services are provided by Piermont Bank, Member FDIC. The funds in your account are FDIC-insured up to $250,000 per depositor for each account ownership category. Advanced, optional add-on bookkeeping software available with a Found Plus subscription. There are no monthly account maintenance fees, but transactional fees for wires, instant transfers, and ATM apply. Read more here: Fee Schedule
The undeniable truth in Richard’s answer is that Go is successful and popular and this means people talk about it more. So whether people like it or hate it or somewhere in between, you’re going to hear more about it. You don’t hear many people criticising Algol 68’s design because nobody ever used it.
OK, so, beyond that, is Go disproportionately attracting criticism for its design, beyond what could be accounted for by its popularity? Yes. Is that criticism unfair? That’s complicated.
- A lot of people care about language design (which is a good thing).
- The designers of Go really don’t (which wor
The undeniable truth in Richard’s answer is that Go is successful and popular and this means people talk about it more. So whether people like it or hate it or somewhere in between, you’re going to hear more about it. You don’t hear many people criticising Algol 68’s design because nobody ever used it.
OK, so, beyond that, is Go disproportionately attracting criticism for its design, beyond what could be accounted for by its popularity? Yes. Is that criticism unfair? That’s complicated.
- A lot of people care about language design (which is a good thing).
- The designers of Go really don’t (which worked for them).
If you’re a Go fan and about to shoot me, please pause to read How I Learned to Stop Worrying and Love Golang, which is the most reasonable article on the subject I’ve yet read.
tl;dr Go is not a design, it’s a collection of solutions to specific use cases. Some of those solutions are smart, some of them are a bit ugly and they do NOT form a coherent whole but the whole thing seems to work reasonably well within a certain range of problem spaces, which is more than you can say about some languages whose designers did care about design (insert your most hated language here and assume I’m a genius who agrees with you).
I work in what’s currently labelled “DevOps” and if somebody working for me tells me they’d like to design or contribute to a project, I’d be happier to hear it was written in Go than C, C++ or Ruby, given both the problem domain and their likely skills.
But
Language design is still important. I’ve had people who work for me tell me that nobody will ever need to use anything but Go ever again. Not the smartest people who work for me.
If you want to tell me that Go works well enough, I won’t argue. If you want - as many do - to use it as an argument for some design principles or against others, I will likely disagree with you vehemently. Why?
- Go is a collection of practical decisions which work well enough. None of those decisions by themselves is anything special or something that another language needs to adopt as a founding principle.
- Some of Go’s features are simply contradictory (no to a ternary operator but yes to for…in…range?) and work “well enough” together only because there’s a limited set of them. Contradictory features are not a thing to admire and emulate.
- Following from the last point, while Go is less complex than many languages, it’s more complicated than it should be. Many Go advocates simply don’t know the difference between complex and complicated. Language designers should. People who argue about language design but don’t understand the difference are wasting everybody’s time.
Just to take one example, I actually like the compile-time duck-typing of Go’s interface concept. But I think Go would be a more powerful, more consistent and less complicated language if the for…in…range control structure (and the cap, len and make functions) worked with any type that had the right methods. Go has interfaces, this is a perfect use for them.
Now, the Go designers decided that generics were useful only for the few types they had built into the language. Which is a reasonable decision within Google’s ecosystem. Because inside Google, if Google’s top techs decide that only a few collection types are needed within a particular domain, that works. But as a more general purpose language in the larger world, it’s a serious limitation.
Go’s designers made entirely reasonable decisions for a language they wrote purely for Google’s use. Some of the core team have been very open and reasonable about the costs and trade-offs around not having generics in a typesafe language. I respect those arguments. I also like the way Go has dragged some of our industry’s neanderthals from the 60s into the 90s.
Just don’t use Go as an argument for the future of programming languages in general. The language designers didn’t intend that (nor care).
On the specific argument about for…in…range and on generics, a large number of people who don’t work at Google have said “I don’t care that I can’t write my own collection types and can’t use generics. I never do that.” I have no respect for that argument. You may choose to limit yourself, but those happen to be powerful tools that other people can use entirely sanely to improve the libraries available in your favourite language. But Go says “You aren’t smart enough to do that. We don’t trust you.” That’s a unique position for a general purpose language whose compiler is written in the same language.
Go receives a lot of criticism because it deserves a lot of criticism as mainstream language good for all kinds of tasks. That isn’t to say that other mainstream languages don’t also deserve a lot of criticism, but we have heard those already; Go is comparatively new, so it’s worth talking about what is wrong with it.
Go does not excel at anything. Simplicity? Python has it beat. Speed? Rust runs rings around it. Concurrency? Not like Elixir. Libraries for everything, including the toughest corporate tasks? Not like Java. Uses types to keep you from doing dumb stuff? Not like Haskell or Scala.
Go receives a lot of criticism because it deserves a lot of criticism as mainstream language good for all kinds of tasks. That isn’t to say that other mainstream languages don’t also deserve a lot of criticism, but we have heard those already; Go is comparatively new, so it’s worth talking about what is wrong with it.
Go does not excel at anything. Simplicity? Python has it beat. Speed? Rust runs rings around it. Concurrency? Not like Elixir. Libraries for everything, including the toughest corporate tasks? Not like Java. Uses types to keep you from doing dumb stuff? Not like Haskell or Scala. Just plain getting stuff done? Not like Python (or Scala, or …). And so on.
Depending on what you want to excel at, you can find plenty to criticize.
Go’s sweet spot is that it is a good enough compromise in several areas to be the best tool for some jobs. It’s pretty easy to understand—you can get into it quickly and you won’t have many surprises from the language itself. It’s pretty fast—you need to be doing something really demanding to be worth switching away from Go for speed. There are quite a few libraries covering a lot of the most important tasks. The type system keeps you from making the very dumbest, most common mistakes. If you’ve been saddled with languages that are a poor fit for the job, or simply involve a lot more ceremony and complexity than is needed, Go can be a wonderful breath of fresh air. I can understand why some people love it. It’s simple, fast, and useful.
But I wouldn’t use Go myself for anything. For literally anything I want to do, I know a language that better fulfills the requirements. And if you try to get me to use Go instead, well, you’re going to hear plenty of (entirely valid) criticisms and case studies where people switched away from Go for very good reasons, e.g. Why Discord is switching from Go to Rust.
Anecdotal evidence: most of the time when I thought I hit an obstacle due to bad language design - it was really because I wasn’t thinking in terms of Go.
I haven’t needed reflect at all yet (though I haven’t written general-purpose libraries), I’ve only had a tiny handful of slightly overly verbose switch-on-types, and assertions mostly look just fine where I need ’em. I have written several thousands of lines of Go code for backend web/network services and feel the results are far superior to my past projects in a similar space (where I would have used PHP and/or C).
The trick is that some of
Anecdotal evidence: most of the time when I thought I hit an obstacle due to bad language design - it was really because I wasn’t thinking in terms of Go.
I haven’t needed reflect at all yet (though I haven’t written general-purpose libraries), I’ve only had a tiny handful of slightly overly verbose switch-on-types, and assertions mostly look just fine where I need ’em. I have written several thousands of lines of Go code for backend web/network services and feel the results are far superior to my past projects in a similar space (where I would have used PHP and/or C).
The trick is that some of the times I hit those obstacles mentioned above, they weren’t showstoppers - I had solved the problem, it was just *ugly* and I knew in my gut that it wasn’t the improvement others were talking about. Had I stopped there I would think the language was bad. By talking it out with more experienced Go coders, and thinking about things differently than I had been, I found more elegant solutions by using the language the way it was meant to be used.
So what’s the answer to the question here? Honestly, I think it’s ego. The Go designers are clearly more experienced than I am - despite my having coded in a dozen languages or so over the years. Most likely they are more experienced than most of their critics too.
On paper - yeah the critics can talk about how embedded types aren’t really oop or duck typing with interfaces doesn’t solve certain classes of theoretical problems or how relying on runtime error checking against assertions is a wolf in sheep’s clothing... on paper, lots of the criticism is spot on and scary.
But in the real world, I simply haven’t come across a problem yet which didn’t have an elegant solution in Go. That’s just anecdotal - but it’s a fact and a really tough thing to explain…
The problem is that it’s also kindof an elusive thing to give over - I don’t think anyone’s really well cracked the issue of how to shift your thinking to Go’s way of doing things and the mechanics of how it happens to just work out all the time. I mean just for an example- taking that point above how runtime checking against assertions on an interface{}… on paper that’s as awful as any ol’ “var” in javascript. But in reality - the cases where I actually could have an error against those assertions would be more due to real system error than not knowing the value ahead of time. It’s a tough thing to explain, but well written Go code just has this way of working out like that.
It’s a tough pill to swallow for most devs, that on paper they’re right, but in the real world they’re wrong and the Go designers somehow anticipated all those real world problems. *shrug*
The best freelance digital marketers can be found on Fiverr. Their talented freelancers can provide full web creation, or anything Shopify on your budget and deadline. If you’re looking for someone who can do Magento, Fiverr has the freelancers qualified to do so. If you want to do Dropshipping, PHP, or, GTmetrix, Fiverr can help with that too. Any digital marketing help you need Fiverr has freelancers qualified to take the reins. What are you waiting for? Start today.
I suspect most of the people that have commented on this thread haven't spent 2 1/2 years writing production go, and therefore are missing the key points.
Go isn't supposed to be interesting, or even fun. It's meant to get shit done (although I find that a lot of fun). While I find this topic mostly amusing at this point, the real proof is in the companies that are adopting it to solve real pro
I suspect most of the people that have commented on this thread haven't spent 2 1/2 years writing production go, and therefore are missing the key points.
Go isn't supposed to be interesting, or even fun. It's meant to get shit done (although I find that a lot of fun). While I find this topic mostly amusing at this point, the real proof is in the companies that are adopting it to solve real problems. If you want to know if go is good for you, then go talk to an engineering team that is deeply vested in it. They will all have engineers that are familiar with ...
Go is a language that works great in practice but not in theory. People who like learning programming languages for the sake of learning something new and different hate Go. People who like getting stuff done love Go.
There's a reason that companies with great engineering cultures are switching to Go. These include companies like Dropbox and MongoDB.
Just have a look at the companies that are advertising jobs for Go: Go jobs and contracting positions
- Sourcegraph
- Enigma
- Wal-mart
- Hailo
- Timehop
- Yo
- IMVU
- SoundCloud
- Canonical (makers of Ubuntu)
- Dropbox
- Apple
- Gree
- Twitch
- Yhat
- Civis Analytics
- Heroku
- Mailgun
- Pivot
Go is a language that works great in practice but not in theory. People who like learning programming languages for the sake of learning something new and different hate Go. People who like getting stuff done love Go.
There's a reason that companies with great engineering cultures are switching to Go. These include companies like Dropbox and MongoDB.
Just have a look at the companies that are advertising jobs for Go: Go jobs and contracting positions
- Sourcegraph
- Enigma
- Wal-mart
- Hailo
- Timehop
- Yo
- IMVU
- SoundCloud
- Canonical (makers of Ubuntu)
- Dropbox
- Apple
- Gree
- Twitch
- Yhat
- Civis Analytics
- Heroku
- Mailgun
- Pivotal labs
- 99 designs
- Nitrous.IO
- CB Insights
- SendGrid
- Digital Ocean
- Iron.io | Powering Scalable Apps
- Docker
The very vocal Haskell supporters hate this because it totally boggles them that an inferior language is becoming so widely adopted so quickly.
Where do I start?
I’m a huge financial nerd, and have spent an embarrassing amount of time talking to people about their money habits.
Here are the biggest mistakes people are making and how to fix them:
Not having a separate high interest savings account
Having a separate account allows you to see the results of all your hard work and keep your money separate so you're less tempted to spend it.
Plus with rates above 5.00%, the interest you can earn compared to most banks really adds up.
Here is a list of the top savings accounts available today. Deposit $5 before moving on because this is one of th
Where do I start?
I’m a huge financial nerd, and have spent an embarrassing amount of time talking to people about their money habits.
Here are the biggest mistakes people are making and how to fix them:
Not having a separate high interest savings account
Having a separate account allows you to see the results of all your hard work and keep your money separate so you're less tempted to spend it.
Plus with rates above 5.00%, the interest you can earn compared to most banks really adds up.
Here is a list of the top savings accounts available today. Deposit $5 before moving on because this is one of the biggest mistakes and easiest ones to fix.
Overpaying on car insurance
You’ve heard it a million times before, but the average American family still overspends by $417/year on car insurance.
If you’ve been with the same insurer for years, chances are you are one of them.
Pull up Coverage.com, a free site that will compare prices for you, answer the questions on the page, and it will show you how much you could be saving.
That’s it. You’ll likely be saving a bunch of money. Here’s a link to give it a try.
Consistently being in debt
If you’ve got $10K+ in debt (credit cards…medical bills…anything really) you could use a debt relief program and potentially reduce by over 20%.
Here’s how to see if you qualify:
Head over to this Debt Relief comparison website here, then simply answer the questions to see if you qualify.
It’s as simple as that. You’ll likely end up paying less than you owed before and you could be debt free in as little as 2 years.
Missing out on free money to invest
It’s no secret that millionaires love investing, but for the rest of us, it can seem out of reach.
Times have changed. There are a number of investing platforms that will give you a bonus to open an account and get started. All you have to do is open the account and invest at least $25, and you could get up to $1000 in bonus.
Pretty sweet deal right? Here is a link to some of the best options.
Having bad credit
A low credit score can come back to bite you in so many ways in the future.
From that next rental application to getting approved for any type of loan or credit card, if you have a bad history with credit, the good news is you can fix it.
Head over to BankRate.com and answer a few questions to see if you qualify. It only takes a few minutes and could save you from a major upset down the line.
How to get started
Hope this helps! Here are the links to get started:
Have a separate savings account
Stop overpaying for car insurance
Finally get out of debt
Start investing with a free bonus
Fix your credit
In my opinion it is mainly criticised for its lack of features by people who have become accustomed to languages with more features.
The other side of the coin is that it is this very lack of features that makes it a simple and attractive language to many people. Many experienced programmers, myself included, find that it provides just the primitives they need to produce understandable and maintainable programs.
In particular its focus on composition over inheritance makes for programs that are often easy to refactor, which is a huge win in the face of changing specs and ever-evolving code.
Its s
In my opinion it is mainly criticised for its lack of features by people who have become accustomed to languages with more features.
The other side of the coin is that it is this very lack of features that makes it a simple and attractive language to many people. Many experienced programmers, myself included, find that it provides just the primitives they need to produce understandable and maintainable programs.
In particular its focus on composition over inheritance makes for programs that are often easy to refactor, which is a huge win in the face of changing specs and ever-evolving code.
Its simplicity also means that it is viable for regular programmers to write meta-tools that manipulate Go source code in useful ways.
These properties are directly opposed to the features that many of the people who criticise Go feel are necessary. Simplicity is a hard road to travel - it's the reason for Go's harsh criticism but also for its manifest success.
Human nature. Go is rapidly being adopted. This is threatening to people that have heavily invested in other languages. It doesn't help that Go is simple and straight forward so the bar has been lowered on mastery. There is also a certain academic appeal and elitism with complex languages.
Simplicity is the best feature a language can have. This goes against a lot of languages that add feature after feature and try be all things to all programmers. Go is not perfect, but all languages are flawed depending on the perspective. Go is pragmatic and pragmatic is never sexy. Well unless you care ab
Human nature. Go is rapidly being adopted. This is threatening to people that have heavily invested in other languages. It doesn't help that Go is simple and straight forward so the bar has been lowered on mastery. There is also a certain academic appeal and elitism with complex languages.
Simplicity is the best feature a language can have. This goes against a lot of languages that add feature after feature and try be all things to all programmers. Go is not perfect, but all languages are flawed depending on the perspective. Go is pragmatic and pragmatic is never sexy. Well unless you care about scaling, implementation time, code maintenance and reliability. Then maybe it is.
Here’s the thing: I wish I had known these money secrets sooner. They’ve helped so many people save hundreds, secure their family’s future, and grow their bank accounts—myself included.
And honestly? Putting them to use was way easier than I expected. I bet you can knock out at least three or four of these right now—yes, even from your phone.
Don’t wait like I did. Go ahead and start using these money secrets today!
1. Cancel Your Car Insurance
You might not even realize it, but your car insurance company is probably overcharging you. In fact, they’re kind of counting on you not noticing. Luckily,
Here’s the thing: I wish I had known these money secrets sooner. They’ve helped so many people save hundreds, secure their family’s future, and grow their bank accounts—myself included.
And honestly? Putting them to use was way easier than I expected. I bet you can knock out at least three or four of these right now—yes, even from your phone.
Don’t wait like I did. Go ahead and start using these money secrets today!
1. Cancel Your Car Insurance
You might not even realize it, but your car insurance company is probably overcharging you. In fact, they’re kind of counting on you not noticing. Luckily, this problem is easy to fix.
Don’t waste your time browsing insurance sites for a better deal. A company called Insurify shows you all your options at once — people who do this save up to $996 per year.
If you tell them a bit about yourself and your vehicle, they’ll send you personalized quotes so you can compare them and find the best one for you.
Tired of overpaying for car insurance? It takes just five minutes to compare your options with Insurify and see how much you could save on car insurance.
2. Ask This Company to Get a Big Chunk of Your Debt Forgiven
A company called National Debt Relief could convince your lenders to simply get rid of a big chunk of what you owe. No bankruptcy, no loans — you don’t even need to have good credit.
If you owe at least $10,000 in unsecured debt (credit card debt, personal loans, medical bills, etc.), National Debt Relief’s experts will build you a monthly payment plan. As your payments add up, they negotiate with your creditors to reduce the amount you owe. You then pay off the rest in a lump sum.
On average, you could become debt-free within 24 to 48 months. It takes less than a minute to sign up and see how much debt you could get rid of.
3. You Can Become a Real Estate Investor for as Little as $10
Take a look at some of the world’s wealthiest people. What do they have in common? Many invest in large private real estate deals. And here’s the thing: There’s no reason you can’t, too — for as little as $10.
An investment called the Fundrise Flagship Fund lets you get started in the world of real estate by giving you access to a low-cost, diversified portfolio of private real estate. The best part? You don’t have to be the landlord. The Flagship Fund does all the heavy lifting.
With an initial investment as low as $10, your money will be invested in the Fund, which already owns more than $1 billion worth of real estate around the country, from apartment complexes to the thriving housing rental market to larger last-mile e-commerce logistics centers.
Want to invest more? Many investors choose to invest $1,000 or more. This is a Fund that can fit any type of investor’s needs. Once invested, you can track your performance from your phone and watch as properties are acquired, improved, and operated. As properties generate cash flow, you could earn money through quarterly dividend payments. And over time, you could earn money off the potential appreciation of the properties.
So if you want to get started in the world of real-estate investing, it takes just a few minutes to sign up and create an account with the Fundrise Flagship Fund.
This is a paid advertisement. Carefully consider the investment objectives, risks, charges and expenses of the Fundrise Real Estate Fund before investing. This and other information can be found in the Fund’s prospectus. Read them carefully before investing.
4. Earn Up to $50 this Month By Answering Survey Questions About the News — It’s Anonymous
The news is a heated subject these days. It’s hard not to have an opinion on it.
Good news: A website called YouGov will pay you up to $50 or more this month just to answer survey questions about politics, the economy, and other hot news topics.
Plus, it’s totally anonymous, so no one will judge you for that hot take.
When you take a quick survey (some are less than three minutes), you’ll earn points you can exchange for up to $50 in cash or gift cards to places like Walmart and Amazon. Plus, Penny Hoarder readers will get an extra 500 points for registering and another 1,000 points after completing their first survey.
It takes just a few minutes to sign up and take your first survey, and you’ll receive your points immediately.
5. This Online Bank Account Pays 10x More Interest Than Your Traditional Bank
If you bank at a traditional brick-and-mortar bank, your money probably isn’t growing much (c’mon, 0.40% is basically nothing).1
But there’s good news: With SoFi Checking and Savings (member FDIC), you stand to gain up to a hefty 3.80% APY on savings when you set up a direct deposit or have $5,000 or more in Qualifying Deposits and 0.50% APY on checking balances2 — savings APY is 10 times more than the national average.1
Right now, a direct deposit of at least $1K not only sets you up for higher returns but also brings you closer to earning up to a $300 welcome bonus (terms apply).3
You can easily deposit checks via your phone’s camera, transfer funds, and get customer service via chat or phone call. There are no account fees, no monthly fees and no overdraft fees.* And your money is FDIC insured (up to $3M of additional FDIC insurance through the SoFi Insured Deposit Program).4
It’s quick and easy to open an account with SoFi Checking and Savings (member FDIC) and watch your money grow faster than ever.
Read Disclaimer
5. Stop Paying Your Credit Card Company
If you have credit card debt, you know. The anxiety, the interest rates, the fear you’re never going to escape… but a website called AmONE wants to help.
If you owe your credit card companies $100,000 or less, AmONE will match you with a low-interest loan you can use to pay off every single one of your balances.
The benefit? You’ll be left with one bill to pay each month. And because personal loans have lower interest rates (AmONE rates start at 6.40% APR), you’ll get out of debt that much faster.
It takes less than a minute and just 10 questions to see what loans you qualify for.
6. Earn Up to $225 This Month Playing Games on Your Phone
Ever wish you could get paid just for messing around with your phone? Guess what? You totally can.
Swagbucks will pay you up to $225 a month just for installing and playing games on your phone. That’s it. Just download the app, pick the games you like, and get to playing. Don’t worry; they’ll give you plenty of games to choose from every day so you won’t get bored, and the more you play, the more you can earn.
This might sound too good to be true, but it’s already paid its users more than $429 million. You won’t get rich playing games on Swagbucks, but you could earn enough for a few grocery trips or pay a few bills every month. Not too shabby, right?
Ready to get paid while you play? Download and install the Swagbucks app today, and see how much you can earn!
For the first time in ages, there is a language that does not get in the way of doing things. Language creators and enthusiasts tend to forget that programming languages are ultimately just tools, and eventually herald them on a pedestal adding more advanced, complex features that just keep building up on the cognitive load of the language users (aka product developers).
For instance, I was a Pythonista. I spent years with it until I learned Ruby and how fancy and fun it was. After a while, there was just so many fancy ways of doing things I had to learn that it beat the reason to program. So I
For the first time in ages, there is a language that does not get in the way of doing things. Language creators and enthusiasts tend to forget that programming languages are ultimately just tools, and eventually herald them on a pedestal adding more advanced, complex features that just keep building up on the cognitive load of the language users (aka product developers).
For instance, I was a Pythonista. I spent years with it until I learned Ruby and how fancy and fun it was. After a while, there was just so many fancy ways of doing things I had to learn that it beat the reason to program. So I left the beau and headed back to the more boring but straight-to-the-point Python. That was when Python became an awkward teen, trying to get past v2. A lot of awkward, half-baked and more complex features were added to the once simple, getting-shit-done language. Now Python has become a rightful, bloated language as well.
Go, on the other hand, made itself clear from the start not be be that. It doesn’t even have classes, which, to many’s surprises, has been working out very well. Then people realized class-based OOP, which was invented by theorists, has always been unnecessary. I think this is what made a lot of people against Go—it slaps them in the face, like how JavaScript has done and still is.
This is not to say that other languages are no good. In fact, it is always interesting to learn them. However, it is also very interesting to be able to build something quickly and keep the interest level healthy. Try learning Scala from scratch (that means not coming from Java or a functional language) and one will realize how many concepts he/she has to learn even before being able to write a respectable program.
By the way, JavaScript is a living proof that not “good” languages survive the test of time but rather intuitive ones that are pleasant to work with and accessible to all.
I have worked in several different paradigms over my career. I think if I was presently working in a low-level paradigm, I might embrace Go in a heartbeat.
My reservation about Go is that it would be used in paradigms that it is a misfit for based solely on the strength of Google's marketing ability.
I read a dumb article recently advising "what developers want." Included in that was, "They want to work in modern languages like Go. [Big Name X] says all the most interesting projects are written in Go." This is such idiocy it makes me cringe. It's like carpenters running around and saying "a
I have worked in several different paradigms over my career. I think if I was presently working in a low-level paradigm, I might embrace Go in a heartbeat.
My reservation about Go is that it would be used in paradigms that it is a misfit for based solely on the strength of Google's marketing ability.
I read a dumb article recently advising "what developers want." Included in that was, "They want to work in modern languages like Go. [Big Name X] says all the most interesting projects are written in Go." This is such idiocy it makes me cringe. It's like carpenters running around and saying "all the most interesting projects use screwdrivers!"
This especially makes my heart sink because I'm forced to routinely use PowerShell for a scripting task Python could accomplish about a million times better, based solely on Microsoft's marketing strength and the relative language ignorance of this project's decision makers. The man-hours lost on this horrible choice are stunning and it shows no sign of ever ending.
Similarly, the Google hype machine means Go will go to the head of the line in front of much more suitable languages for given tasks because some manager is unduly influenced in his choices by marketroids. It means further lack of acceptance for the functional and multiparadigm functional-OOP languages. It means a reduced chance of ever getting to work in those spectacular languages because some people think "easy" and "trendy" are the only important criteria in language selection.
I think there are two reasons;
Go has startled a whole bunch of people as a result of the surge in its popularity and use. They find this upsetting
Go threatens the “preisthood” that collective of assholes who really do despite ordinary developers who just want to get shit done.
Go is an amazing language because it enables a regular developer to do stuff that would have required a ninja previously.
Yes, there are languages that are “better in a pureness sense”… but whether it's lisp, rust, or (if you're really in denial… a truly shitty language like JavaScript or ruby) it's all right and good to h
I think there are two reasons;
Go has startled a whole bunch of people as a result of the surge in its popularity and use. They find this upsetting
Go threatens the “preisthood” that collective of assholes who really do despite ordinary developers who just want to get shit done.
Go is an amazing language because it enables a regular developer to do stuff that would have required a ninja previously.
Yes, there are languages that are “better in a pureness sense”… but whether it's lisp, rust, or (if you're really in denial… a truly shitty language like JavaScript or ruby) it's all right and good to have your faintly masturbatory waffling about the superiority of your chosen language … but while you're pontificating , go programmers will be getting stuff done. Writing clear, maintianabke code that future developers will be able to understand and modify without having to get into the head of whatever psychopathic “Smalltalk guru” wrote it in the first place.
There are two (or maybe three) types of belief clubs among Software Engineers :
1. Software has become huge, so we need to make simple and powerful tools so that programmers can wrap their heads around it.
2. Software has become huge, so we need to make sophiisticated and powerful tools that can help programmers help their head around it.
3. Right tool for the right job guys.
Type 2 is the type of people that is extremly vocal about their preference and they dont like language with less features (no typeclasses, monads, monoids, functors, memory ownership and such features in Go). There are reg
There are two (or maybe three) types of belief clubs among Software Engineers :
1. Software has become huge, so we need to make simple and powerful tools so that programmers can wrap their heads around it.
2. Software has become huge, so we need to make sophiisticated and powerful tools that can help programmers help their head around it.
3. Right tool for the right job guys.
Type 2 is the type of people that is extremly vocal about their preference and they dont like language with less features (no typeclasses, monads, monoids, functors, memory ownership and such features in Go). There are regular huge discussions about Rust, Haskell and other languages which belong to ideology 2, depite of the languages not being very commonplace. They believe languages like Go (and Java) dumb people down. This does not mean a lot of people subscribe to such views, just that they do not come out and discuss as much.
Type 1 people are generally Go fans and type 3 people will not criticise Go as they know that Go is a excellent langauge for the cases it is generally put in use for, might be bad for other cases. A lot of such people believe too much of mathy features deviate language from its features (solving problems) and make it focus on correcting each others maths.
An analogy is music where classical and intellectual type of music is generally admired by learnt people, but you cannot package them into albums and sell them to everyone. Some features from classical music might make an album very popular though.
A lot of people find it very hard how the other side thinks like, that is the reason any discussion (politics, language, sport teams) erupts, same is the case here. Just my personal perception.
It's a function of its hype to quality ratio.
On the one hand, it isn't a very good language, for lots of reasons I've gone into at length elsewhere.
On the other, it's gotten a lot of praise, popularity and publicity because of the people behind it, Google's support and its tooling. None of these are part of the language itself! It was designed to have a simple implementation which sounds good until you realize that means it compromises your experience to make their experience better!
The main part of the language that lends itself to all this publicity is that it's very accessible; people oft
It's a function of its hype to quality ratio.
On the one hand, it isn't a very good language, for lots of reasons I've gone into at length elsewhere.
On the other, it's gotten a lot of praise, popularity and publicity because of the people behind it, Google's support and its tooling. None of these are part of the language itself! It was designed to have a simple implementation which sounds good until you realize that means it compromises your experience to make their experience better!
The main part of the language that lends itself to all this publicity is that it's very accessible; people often say they're using it because it took almost no effort to learn. That is, it presents almost nothing new--even among mainstream languages! Not wanting to learn new things is not a good reason to choose a language, but it is a popular reason.
Ultimately, Go is just a Java-fied C, with a similar corporation-backed adoption curve to Java proper. I think it's pretty clear why people, especially those interested in programming languages and tired of Java, would criticize that.
A special additional reason only applies to programming language enthusiasts: Go is afflicted with horrible NIH syndrome as far as language design goes. It wantonly ignores the last few decades of programming language development and research, which has included things like efficient, structurally typed generics with full inference--strictly better than what Go offers. So that's why people interested in programming language design, often the most vocal on the subject, would subject Go to especial criticism. It basically undoes a few decades of progress. A step backwards not forwards.
And yet it's still popular and still hyped. Fancy that.
Go is hated and loved because it is opinionated. If make something with strong appeal to many people it will be necessity produce strong dislike among others. Look at Apple and Tesla. Both loved and hated. If you don’t offend anyone you probably don’t appeal to anyone either.
Many programming language snobs didn’t like that Go did not support generics upon release. They also disliked that Go had nu
Go is hated and loved because it is opinionated. If make something with strong appeal to many people it will be necessity produce strong dislike among others. Look at Apple and Tesla. Both loved and hated. If you don’t offend anyone you probably don’t appeal to anyone either.
Many programming language snobs didn’t like that Go did not support generics upon release. They also disliked that Go had null pointers. Basically it is the kind of people ...
I have briefly played with Go, and have done Erlang & Elixir development.
You can “get shit done” in Go, but you can also get the same shit done in Erlang. And since Erlang has been around much longer, it has a richer ecosystem than Go, especially the OTP.
With Erlang, it is possible to write your code in a server-agnostic way, so that it does not care where it’s running. I don’t think that is as easy to do with Go. Erlang was built for this.
I also don’t like how Go forces you to use tabs for all of your spacing. Nor do I like its project layout, which tries to mirror Java’s layout a bit.
So betw
I have briefly played with Go, and have done Erlang & Elixir development.
You can “get shit done” in Go, but you can also get the same shit done in Erlang. And since Erlang has been around much longer, it has a richer ecosystem than Go, especially the OTP.
With Erlang, it is possible to write your code in a server-agnostic way, so that it does not care where it’s running. I don’t think that is as easy to do with Go. Erlang was built for this.
I also don’t like how Go forces you to use tabs for all of your spacing. Nor do I like its project layout, which tries to mirror Java’s layout a bit.
So between the two, I would choose Erlang. Been around since the 80s, has been battle-tested, and is geared for high levels of concurrency on limited hardware. Go can do this as well, but it has too much attitude and not enough of the right stuff in my view.
Now someday I’ll make a comparison between Go and Haskell. Now that would be fun!
You know how if you try to satisfy everyone you end up with something really bland? Try making a house or a car design that everybody likes, or at least nobody hates. It will end up uninspiring and bland. The creators of Go didn’t set out to create a language for everybody to like but to make a language which a large number of people would love. By necessity that also gives haters.
Imagine the most
You know how if you try to satisfy everyone you end up with something really bland? Try making a house or a car design that everybody likes, or at least nobody hates. It will end up uninspiring and bland. The creators of Go didn’t set out to create a language for everybody to like but to make a language which a large number of people would love. By necessity that also gives haters.
Imagine the most awesome looking car design. Chances are somebody will really hate what you think is the most awesome looking. Programming languages are kind of the same. They are as much about art as about science. There are lots of programming language features out there you can mix together. Some try to through together as many features as possible but that generally results in horrible languages nobody likes. The trick is to come up with a mix of features which has appeal to a large number of people. Not every group of people will like the same mix. We developers are different. We have different preferences.
Go focuses mainly on simplicity, ease of use, ease of learning and pragmatism. That doesn’t appeal very much to what I would call programming language snobs. There are a lot of people who want a language to check as many bo...
Claiming concurrency and then using a poor solution.
Cooperative.. I mean… Really?
Shared mutable state hidden behind a Channel .. Eh? Yuk?
What’s faintly annoying is that other languages have clearly demonstrated better idioms ( Erlang ).. so why the failure to learn?
But.. is it heavily criticised? If I put another lens in.. a better version of C.. well.. its pretty good right? It has simplicity, low level semantics, an imperative feel.. these have been shown to be solid, popular approaches…
I have not looked at Go and don’t know it, so I can’t comment on Go. But if some of the answers here are an indication, it is not the detractors that scare me about Go - it is the supporters and some of the horrifying answers. Richard Eng for example very often writes really good answers, especially about Smalltalk. But I don’t like his characterisation of Go as being pragmatic, implying for real-world programmers rather than those theoretical ‘nice’ language types. Well, all computing is theoretical and abstract. Any program only models the ‘real world’ in a theoretical sense. The whole reaso
I have not looked at Go and don’t know it, so I can’t comment on Go. But if some of the answers here are an indication, it is not the detractors that scare me about Go - it is the supporters and some of the horrifying answers. Richard Eng for example very often writes really good answers, especially about Smalltalk. But I don’t like his characterisation of Go as being pragmatic, implying for real-world programmers rather than those theoretical ‘nice’ language types. Well, all computing is theoretical and abstract. Any program only models the ‘real world’ in a theoretical sense. The whole reasoning about pragmatic ‘real world’ programmers who are doing ‘real work’ is just bogus. Want to do real work - go out and become a construction worker.
“Keep the language very small, simple, and easy-to-learn.” Well, small and simple does not mean easy to learn. C is small and simple and yet because of its flaws is very difficult to learn. C++ just opens the can of worms to its logical conclusion.
“However, there’s no denying that it works. And it works well” Well, all languages work, so long as they implement a few very simple programming concepts.
“They’re royally pissed off at Go users who only want to get shit done as quickly and as easily as possible”. Or Cory LaNou “It's meant to get shit done”.
What is this getting s*** done? What vague emotive language. “Oh, yeah, cool man, I know what he means”. Ugh! Programming needs to be more precise than that. If you want to get that done - go sit on a toilet, please. Sounds like you are laying some smelly mess - and very often ‘real world’ programmers are. They don’t care about the quality of their code. That leaves it open to all sorts of problems that some other poor person has to take responsibility for and sort out the mess and take it to the nearest sewerage works. I’ve seen enough of that ‘real world’ programming to last several lifetimes. I’ve usually had to clean up the mess from real-world programmers who ‘got s*** done’.
Are people really angry about Go, or do they just pointing out its flaws like I do with C and C++? Maybe they are just angry because Go is a really good language. However, as one person here noted, it has gotos and pointers with pointer arithmetic, so I doubt it is that clean - just propagating the flaws of C.
Brian Lomeland “There is also a certain academic appeal and elitism with complex languages.” Absolutely not. I agree with the thought there is elitism - it is rife in this industry. Yes you could say that about C++. But academics are usually criticised for being simple and aiming for simplicity. Seems they can’t win.
So the criticisms here are against some amorphous group of people we all like to dislike. Set them up as a straw man that we can all aim cheap shots at.
That is what disturbs me about a lot of the answers here.
Anonymous (just as well) “Go is a language that works great in practice but not in theory. People who like learning programming languages for the sake of learning something new and different hate Go. People who like getting stuff done love Go.”
Again setting up this false dichotomy of people who really write ‘real’ programs and those who just play around. Nonsense.
To move on, the industry must move on from this immature thinking. We need to get away from that kind of smugness (elitism) that the C and C++ communities have had (that from the introductory and defensive comments in Kernighan and Ritchie’s The C Programming Language goes back to there.
OK, I’ll go and look at Go. I might like it, but it won’t be for the reasons of the defence put up for it here. It will be for solid programming reasons.
One of the main reasons is how the personas behind the language, mainly Rob Pike, present it. And especially, how they tend to compare it to other languages. You should check “Public Static Void” and “Less is exponentially more”, if you didn’t already.
Or check tweets like:
- Every Java program I use (there are a few) is a resource pig that can't even keep up with my typing and I am not a fast typist (proof)
- Overheard walking by the Java group: "There's definitely a case to be made for generating the factories." (proof)
Or consider how Go 1.5 GC was presented: Go GC: Prioritizing low latency and sim
One of the main reasons is how the personas behind the language, mainly Rob Pike, present it. And especially, how they tend to compare it to other languages. You should check “Public Static Void” and “Less is exponentially more”, if you didn’t already.
Or check tweets like:
- Every Java program I use (there are a few) is a resource pig that can't even keep up with my typing and I am not a fast typist (proof)
- Overheard walking by the Java group: "There's definitely a case to be made for generating the factories." (proof)
Or consider how Go 1.5 GC was presented: Go GC: Prioritizing low latency and simplicity
And here’s an excellent explanation why it’s misleading: Modern garbage collection – Mike’s blog
You don’t see this behavior from people behind Kotlin, Swift or Elixir.
I would have to confess I haven’t seen anyone express actual hate towards the Go programming language. I would also have to confess that I haven’t worked with it before, but I have attended a few presentations about Go, and it has given me at least some insight into its syntax and what people like about it.
Of the people who I have seen, who complain about Go, I don’t sense hate, so much as I sense disappointment. Indeed, the article “Go vs Brand X” — which, in full disclosure, people rightly argue has its problems with logical consistency and cherry-picking — is nonetheless a very good example
I would have to confess I haven’t seen anyone express actual hate towards the Go programming language. I would also have to confess that I haven’t worked with it before, but I have attended a few presentations about Go, and it has given me at least some insight into its syntax and what people like about it.
Of the people who I have seen, who complain about Go, I don’t sense hate, so much as I sense disappointment. Indeed, the article “Go vs Brand X” — which, in full disclosure, people rightly argue has its problems with logical consistency and cherry-picking — is nonetheless a very good example of why people are disappointed. Fifty years of computer language research, and the best we can do … is Go?
From what I have seen, I find Go kindof amusing, albeit retrograde in some ways, and clumsy in certain ways, too, but I can kindof see what people like about it. I can see why some people would like it, some people would tolerate it, and some people … are disappointed.
And for good reason, too, I might add. Having explored what Common Lisp has, I cannot help but think that everyone should be using some form of Lisp. That form would have Actors for dealing with concurrency, something like the Common Lisp Object System and Meta-Object Protocol for dealing with object-oriented programming, Object Capabilities for handling security and permissions, Conditionals for handling errors and other extraordinary events, Pattern Matching because it’s just plain cool, an optional type system for optimization and a just-in-time compiler to make optimization less necessary, Delta-and-Timestamp file and memory access to handle parallel data processing, and a lot of other ideas that I can’t remember off the top of my head right now — but could and would nonetheless revolutionize how we do computing, yet are mostly ignored because we’d have to completely restructure how we do everything, and we, the Industry, like everything just the way it is, Thank You Very Much.
And many of these ideas date back to the late 1950s and early 1960s — yet nonetheless languish in obscurity.
And then, a new language comes along, and it … continues to ignore these ideas … but is heralded as a great advancement in the computer industry, because it enables developers to Get S[tuff] Done™ … just like pretty much every other language before it, sort of, except when it can’t.
And those of us who are even sort of aware of just what is out there, that can greatly stabilize and even simplify computing, just shake our heads in disappointment.
Would I accept a project using Go, if required for a job? Sure. I might even like it as much as when I’ve used Python, and almost certainly more than if I used PHP! But I’m aware of what computing could be, and will nonetheless still be disappointed: seriously, is this still the best we could do?
Go is fast becoming the lingua Franca of the cloud. Why?
- Its baked-in concurrency primitives and excellent supporting runtime
- Its speed and ease of compilation and deployment
- Its readability/maintainability as a primary design goal
- Its excellent tooling
- Its brilliant concurrent garbage collector
- Its relative simplicity as a language
- Its builtin documentation
All of these things combine to make a language that is relatively easy to pick up, and well-positioned for use by large teams, writing microservices in rapid-development cloud infrastrutures, which is a pretty popular way of doing business these d
Go is fast becoming the lingua Franca of the cloud. Why?
- Its baked-in concurrency primitives and excellent supporting runtime
- Its speed and ease of compilation and deployment
- Its readability/maintainability as a primary design goal
- Its excellent tooling
- Its brilliant concurrent garbage collector
- Its relative simplicity as a language
- Its builtin documentation
All of these things combine to make a language that is relatively easy to pick up, and well-positioned for use by large teams, writing microservices in rapid-development cloud infrastrutures, which is a pretty popular way of doing business these days.
One thing that I think disappoints a lot of people when they come to Go is the language does not reward being clever. Go is a fairly simple programming language and it uses simple repetitive constructs. For example you want to loop over something it’s a basic `for` loop. It’s nothing special or spectacular of even very interesting.
For example this function iterates over a bunch of strings and tell
One thing that I think disappoints a lot of people when they come to Go is the language does not reward being clever. Go is a fairly simple programming language and it uses simple repetitive constructs. For example you want to loop over something it’s a basic `for` loop. It’s nothing special or spectacular of even very interesting.
For example this function iterates over a bunch of strings and tells you how long they are.
- // simpleLoop is a function that takes a slice of strings and
- // returns a slice of ints that equal the length of the strings
- func simpleLoop(s []string) []int {
- var r []int
- for _, v := range s {
- r = append(r, len(v))
- }
- return r
- }
The only thing even minority interesting in that loop is the `v := range s`. That loop is the same thing as writing.
- for i := 0; i < len(s); i++ {
- r = append(r, len(s[i]))
- }
So really all that is doing is making your variable `v` inste...
My own opinion is that Google pushed it hard but never gave it a role, so all the warts show through.
My first exposure to it was an introductory video that praised it for...having a fast compiler. I don't know. Maybe I've never been on the truly massive projects that I guess the rest of the industry all does routinely (please note semi-sarcastic tone before responding), but even when we needed to have everything checked in by Friday because the build would take all weekend, this didn't kill productivity.
So, that's the starting point, and the rest just strikes me as yet another me-too "any id
My own opinion is that Google pushed it hard but never gave it a role, so all the warts show through.
My first exposure to it was an introductory video that praised it for...having a fast compiler. I don't know. Maybe I've never been on the truly massive projects that I guess the rest of the industry all does routinely (please note semi-sarcastic tone before responding), but even when we needed to have everything checked in by Friday because the build would take all weekend, this didn't kill productivity.
So, that's the starting point, and the rest just strikes me as yet another me-too "any idiot can make a better Java" project, and we already have plenty of those.
Every language has its flaws, of course, but very few of them have a corporation the size of Google playing up how amazing it is, so the disparity between the hype and the reality is a lot bigger than, say, Ruby.
Of course, this could be a good thing. If the Go team looks at the complaints and updates the language (the original Java and C# were atrocities compared to today's versions, for example), there's a lot of potential. Or they could stick their collective heads in the sand and continue to believe they've invented something new.
Go was heavily inspired by Oberon-2 … which was the language I was campaigning for, in the physics community, as a replacement for Fortran. Unfortunately C++ won that battle because the tooling / library support for Oberon-2 was so fragmented and directionless.
The thing I really liked about Oberon-2 was this:
- “OBERON is based on MODULA-2, it has a few additions (e.g. the facility of extended record types) and several subtractions …”
- The language’s motto: Make it as simple as possible, but not simpler.
The improvement of Oberon over existing languages, was not in feature addition, but in simplific
Go was heavily inspired by Oberon-2 … which was the language I was campaigning for, in the physics community, as a replacement for Fortran. Unfortunately C++ won that battle because the tooling / library support for Oberon-2 was so fragmented and directionless.
The thing I really liked about Oberon-2 was this:
- “OBERON is based on MODULA-2, it has a few additions (e.g. the facility of extended record types) and several subtractions …”
- The language’s motto: Make it as simple as possible, but not simpler.
The improvement of Oberon over existing languages, was not in feature addition, but in simplification / rationalization. My view of Go is that it aims to do the same: take a fresh look at programming end-to-end (language, library, tooling) and make the best clean language we can. Goal being not to include all possible nifty features, but to include enough useful functionality to make doing many nifty things possible.
If Go didn’t bring any improvements over existing languages, it wouldn’t be in widespread use, and it probably wouldn’t have been created. It was developed in response to observed shortcomings of existing languages, by the largest software company in the world, and it succeeded within Google’s brutal survival-of-the-fittest approach to internal technologies.
Beware language bigotry. It’s a fun game, but when you don’t see the point, it’s probably due to lack of domain experience.
Although Go offers numerous nice features for programmers, I think the biggest win is the highly effective native app
If Go didn’t bring any improvements over existing languages, it wouldn’t be in widespread use, and it probably wouldn’t have been created. It was developed in response to observed shortcomings of existing languages, by the largest software company in the world, and it succeeded within Google’s brutal survival-of-the-fittest approach to internal technologies.
Beware language bigotry. It’s a fun game, but when you don’t see the point, it’s probably due to lack of domain experience.
Although Go offers numerous nice features for programmers, I think the biggest win is the highly effective native approach to concurrency. As clock speeds and chip scale improvements are slowing down significantly, the world is shifting from increasingly faster CPUs to slower CPUs but lots of them. This means concurrency. A lot of popular programming languages have no native support for concurrency at all (Python, Ruby). Others handle it with varying degrees of awkwardness - C++, Java, etc. When you’re operating at Google’s scale - or any serious web scale - this sort of clean, logical, performant concurrency is a huge win.
Interface-driven OO enables duck typing and dependency injection, two forms that have proven extremely fruitful out in the real world of 20–30 years of mainstream OOP, while eschewing the complexities of inheritance, which has proven a lot less valuable in practice.
The thing that led me personally to Go was needing to distribute software to heterogenous environments that I couldn’t control or have visibility into. That makes depending on installed interpreters or dynamically linked libraries somewhere between dangerous and impossible. With Go, I can ship statically-linked binaries that just… work. No matter what the system looks like or how it’s configured.
Of course, not everything is perfect. I really, really miss exception handling, but I understand they made a very conscious, deliberate choice to not include it, even if I don’t fully agree with their reasoning. But if writing a bunch of “if actual != expected {}” is the price I have to pay for the other benefits, I’ll cope.
Hype? It ain’t about hype. I use it because it solves my problems.
First off, I’m not sure that Golang has really received a lot of “hype” from anyone. I mean, Node.js has way more hype and grew up around the same time.
But I think there’s a deeper question here around “improvements over existing languages”. The question itself seems to imply that new languages need ever more features to be relevant. In fact, your link describes Go as “stuck in the 70s” several times. But that’s when all of these languages were designed. LISP/Clojure, ML/Scala/F#, C/C++/Java/C#… they’re all evolved from stuff designed in the 70s.
Even things we think of as modern, like Ruby, Py
First off, I’m not sure that Golang has really received a lot of “hype” from anyone. I mean, Node.js has way more hype and grew up around the same time.
But I think there’s a deeper question here around “improvements over existing languages”. The question itself seems to imply that new languages need ever more features to be relevant. In fact, your link describes Go as “stuck in the 70s” several times. But that’s when all of these languages were designed. LISP/Clojure, ML/Scala/F#, C/C++/Java/C#… they’re all evolved from stuff designed in the 70s.
Even things we think of as modern, like Ruby, Python or Javascript are all just variants of ideas from some paper written in the 70s.
To understand why Golang is popular you have to understand the reason for its creation. Go is a language created by Google to solve the type of problems Google has in creating, delivering and maintaining software.
If you break down the complaints against Go, they really fall into two categories.
- This stuff is not as performant as I would like to it to be.
- I hate this programming pattern, why would anyone do it this way?
While people like to complain about these. I would argue that Google views these as purposeful trade-offs.
To point #1, Google has lots of people writing code in C/C++. But it’s slower to build, slower to compile and more error-prone. Rob Pike knows this, he came up with Go while they were waiting for build machines to compile their code. If there is anyone that understands the performance trade-offs they are making, it’s Google.
To point #2, the majority of the complaints are well-recognized.
- People don’t like writing lots of statements to handle exceptions. I get it, but you can’t write Google-scale code if you’re not ready to handle every exception.
- The language doesn’t have operator overloads or other syntactic sugar. That annoys some people, but if you want code at Google’s scale, you value explicitness over syntactic “magic”.
- The dependency system is kind of weak. Again, not something Google really had to deal with when they built the language. But better features are coming along.
At the end of the day, if Golang did “something new”, it’s this:
- Standardized simplicity as a key feature. Even at the expense of writing more code.
- Standardized Channels as the key technology over Threads.
There are 4 main things that Go doesn’t permit in programming — and lots of little things:
- Abstraction
- Reuse
- Separation of Concern
- Safety
So you end up writing a lot of repetitive simple code and ending up with just as many bugs as you would in a more complex language — with no way of improving your codebase other than cutting and pasting the explicit checks and fixes for all your discovered bugs every where.
Go is a good replacement for shell scripting, but anything more complex is probably easier in a more sophisticated programming language like C or JavaScript.
I wrote an average sized project in go and at the beginning i really liked it. But after some time our team hit some kind of ... let's call it style borders. i like the idea behind go, but after working with it for a while i am starting more or less thinking, that in many cases go is not the right solution for us and we should switch the language as soon as possible (maybe to scala).
I am going to speak from my personal perspective. About one month ago I started to code the prototype for an in-memory web service in Python. I really like the elegance of Python and the ability to prototype things quickly in it. I was implementing the necessary algorithms and when I started to benchmark the performance, I soon realized that my service is going to be CPU bound. In spite of my hard work trying to optimize the Python code it was soon clear that I was enable to make it run fast enough.
I needed to switch to a faster language and the alternatives where: C, C++, Java, Scala and Go.
I am going to speak from my personal perspective. About one month ago I started to code the prototype for an in-memory web service in Python. I really like the elegance of Python and the ability to prototype things quickly in it. I was implementing the necessary algorithms and when I started to benchmark the performance, I soon realized that my service is going to be CPU bound. In spite of my hard work trying to optimize the Python code it was soon clear that I was enable to make it run fast enough.
I needed to switch to a faster language and the alternatives where: C, C++, Java, Scala and Go. I really did want to write the whole thing in a garbage collected language so that I can get rid of some of the headaches which both C and C++ gave me so many times. I also wanted to write concurrent code without much of a trouble so at this point C and C++ were pretty much out. I was left with Java, Scala and Go. I hate Java and I was afraid of Scala precisely because I could embed Java code into it. Scala also seemed like it had a steeper learning curve.
The solution ? GO! Go was the perfect language for me. It was garbage collected and it seemed to be the perfect candidate for what I had to do. The syntax isn't so exotic as you would expect it to be. Of course, Go has some peculiarities such as the lack of polymorphic functions (although if you come to think of it this only makes you design cleaner code) and generics. But it doesn't matter because I was almost as productive in Go as I was in python and I was able to see a 10x improvement in the speed of the service by just porting it to Go. Afterwards, I have managed to scale that up to 40x by writing concurrent code using the awesome goroutines.
I also do have the feeling that the tools that come with Go do not get their fair share of attention. The Go profiler is an amazing tool and it has helped me more than I could realize in my journey of optimizing the algorithms.
Overall, to answer your question, Go is right now a viable alternative to writing C++ or Java services. If the majority however doesn't take that into consideration it's a completely different story.
A couple, I guess.
Ask me a year ago, and I would have said the #1 problem with Go was a lack of generics, but they have generics now.
I’d say most of the “problems” in Go stem from not paying attention to what anyone else is doing. There are lots of new languages to come out before Go that had these features, and most of them are features which programmers today value quite a bit, but Go lacks.
- nil is the biggest problem in Go. Most new languages either don’t support empty values or force the programmer to unwrap possible empty values. Ever had a NullPointerException in Java or a segmentation fa
A couple, I guess.
Ask me a year ago, and I would have said the #1 problem with Go was a lack of generics, but they have generics now.
I’d say most of the “problems” in Go stem from not paying attention to what anyone else is doing. There are lots of new languages to come out before Go that had these features, and most of them are features which programmers today value quite a bit, but Go lacks.
- nil is the biggest problem in Go. Most new languages either don’t support empty values or force the programmer to unwrap possible empty values. Ever had a NullPointerException in Java or a segmentation fault in C? Was it fun to debug? Modern programming languages don’t think it’s fun to debug either, so they make it impossible. The creators of Go seem blissfully unaware of the problems created by `nil` because they ignore the various strategies used to make these problems disappear.
- if err != nil { return err, nil }. Go doesn’t make you unwrap nil, but boy howdy, do they ever make you unwrap errors! I’m not the biggest fan of unchecked exceptions: they are fine for some kinds of work and not so much for others. If an operation has the possibility of creating a non-fatal error, I do think it should be explicit and you should have to check for it—just like I think you should have to check for nil. But this constant pattern of `if err != nil { return err, nil }` is just a bit too much. Give us some kind of shorthand for throwing errors up the stack to the point we want to deal with them! It should be explicit, but could definitely be tidied up.
- Everything is mutable in Go. The trend is towards making immutability the default these days and marking mutability explicitly. This is because, just like nil, mutation can be a source of bugs that are difficult to track down. Not only does Go default to mutability, but the language actually has no notion immutability. What Go does have is privacy, so library users cannot mutate objects which shouldn’t be mutated—because they can’t see what’s in it at all. The trend in modern languages is the opposite: transparent objects with immutable properties. I’m all in favor of privacy when it makes sense, but not as a form of protection against mutation—and I’m certainly not a fan of making private properties and then just exposing them again with getters.
As with any question assessing a programming language relative to other programming languages, the answer is “it depends.” It depends on what you plan to do with the language.
I don’t know anything about Kotlin or Dart. I cannot give a comparison to those.
Go is worse than R for anything having to do with statistical analysis and data science.
Go is better than Python for almost all purposes, except for machine learning, scientific analyses, prototyping, and inter-operating with existing Python programs.
Go is better than C for most everything, except for real time programming, and operating syste
As with any question assessing a programming language relative to other programming languages, the answer is “it depends.” It depends on what you plan to do with the language.
I don’t know anything about Kotlin or Dart. I cannot give a comparison to those.
Go is worse than R for anything having to do with statistical analysis and data science.
Go is better than Python for almost all purposes, except for machine learning, scientific analyses, prototyping, and inter-operating with existing Python programs.
Go is better than C for most everything, except for real time programming, and operating system drivers.
Go is better than JavaScript, Python, or Ruby for any large scale project, because static typing makes it much easier to build large scale systems.
Go is better than Swift for programs that need to run on more than the Apple platforms.
Go is better than C++, except when high performance data mangling is the name of the game.
Go is better than Java for building microservices, and many web applications. Go is still not a good choice for building a large scale GUI desktop application, though.
Go is better than Scala for many of the same reasons that it is better than Java, plus it is much less complicated.
Go is better than bash.
Go is a great language to have in your language toolkit, but to do well at software development, make sure to learn others.
I suspect the following properties of Go that go me into the language appeal to a lot of developers. Also Go fits a certain niche that other languages haven’t.
- The creators of Go all have made major contributions to our field in the past, and are people I have a lot of respect for. Here are some highlights for each:
- Robert Griesemer - Previously worked on the V8 Javascript Engine and Java’s JVM.
- Rob Pike - UTF-8, was on the unix team at Bell Labs (where C came from), created the first windowing system for Unix, Plan 9 and it’s follow research project Inferno which laid the foundation for the idea
I suspect the following properties of Go that go me into the language appeal to a lot of developers. Also Go fits a certain niche that other languages haven’t.
- The creators of Go all have made major contributions to our field in the past, and are people I have a lot of respect for. Here are some highlights for each:
- Robert Griesemer - Previously worked on the V8 Javascript Engine and Java’s JVM.
- Rob Pike - UTF-8, was on the unix team at Bell Labs (where C came from), created the first windowing system for Unix, Plan 9 and it’s follow research project Inferno which laid the foundation for the ideas behind the Java Virtual Machine.
- Ken Thompson - Designed and implemented the original Unix. Distinguished Engineer at Google.
- Go has some unique primitives in the language to support concurrency which has become important with the switch to multicore devices.
- Go Routines are lightweight green threads with very little overhead as compared to posix threads. This allows for use of concurrency patterns to not only make use of all cores but simplify problems that are difficult to do in a linear manner (such as parsing).
- Channels are typed, optionally buffered pipes that allow for thread safe communication between threads (go routines).
- The standard library has a nice collections of concurrency tools like sync.Once, Sync.Mutex, and sync.WaitGroup.
- Go compiles to native code and allows for easy cross compilation to another platform. So for instance I can create a executable for Linux on my OS X machine.
- Go approaches interfaces in a unique way. Unlike Java where you have to declare that a type implements an interface, in Go if your type matches the interface’s method signatures then it implements the interface implicitly. This makes them much more flexible and decouples code.
- Go’s type system is pretty nice. You only declare a type when it’s needed, and in most cases the compiler can infer the type from the context. Also there is an the idea of a default zero value for a type which is useful and in many places drops the use of nil/null. This means less method called on nil/null errors due to use of uninitialized variables or where you would get null back when you didn’t expect it. There are a few downsides, in particular mapping types which can’t be null/nil to a database column is tedious and requires wrapping the type (when updating values from a struct do I know the user really selected 0, or just didn’t provide a value so I shouldn’t update the field or my database column is nullable how do I map that to an integer and know if the value is really 0 or just not set). Also I really like Go’s concise and safe approach to type casting.
- It’s a garbage collected language. I don’t know of many out there that doesn’t have a heavy runtime associated with them.
- It compiles to a static binary that will work on most any linux box, or OS X box. All that’s required to distribute your program is to copy the executable file to the machine. Compare this with Java which has a heavy runtime with a complicated license or Ruby where many linux distributions only package an out of date version and requires you compile from source or find a third party provider for packages for you particular distribution.
- The standard library is great. And it has the tools you need bundled with it to create high performance web services that will stand up under load. In addition to the standard lib there is a huge collection of high quality open source packages for distributed computing, network services, web applications. Also interfacing with C code is an incredibly easy thing to do for the most part (it complicates cross platform compilation).
- The tooling is a first class part of the language and well done. The compiler is incredibly fast (it’s rare that I’m having to pause or wait while a project builds). There are tools to refactor your code, answer questions such as who calls this function?, quickly look up documentation, generate code coverage of test, identify unsafe concurrent code, memory profiling and more.
- It’s backed by Google and used in production - it stands up under load, is designed to be used on large teams, has the financial backing and marketing resources, is open source yet we can be fairly confident the language will be around for the long haul if it’s used by Google in production and products like Docker are written in Go.
What really sold me on go was it’s fast, spits out a native binary so distribution is easy, didn’t require me to keep track of memory use on my own, and had a great ecosystem of packages I can pull in and a strong modern standard lib. There are few other languages i know of that can provide this. Common Lisp is the only one that really comes to mind right now.
Go is, in my opinion, an implementation language. Its garbage collector makes it effortless for beginners to develop small programs without concerning themselves with memory allocation.
Interestingly, seasoned programmers, those with over a decade of experience, tend to follow specific programming patterns. Therefore, an interface binding a set of properties in a structure to a set of methods creat
Go is, in my opinion, an implementation language. Its garbage collector makes it effortless for beginners to develop small programs without concerning themselves with memory allocation.
Interestingly, seasoned programmers, those with over a decade of experience, tend to follow specific programming patterns. Therefore, an interface binding a set of properties in a structure to a set of methods creates the concept of multiple inheritance, easily defined in ERDs and implemented in a variety of ways, including embedding. Nonetheless, the language does not implement it, leaving the implementation up to the programmer.
Concurrent programming makes it incredibly easy to create recursive programs, but spawning a near-infinite number of simultaneous jobs results in overwhelming overhead that needs to be managed by worker pools.
Go allows me to be extremely productive. I can focus solely on creating meaningful abstractions and unit tests until I have a functioning program. If the program consumes too much memory and runs too slowly, profiling helps me identify areas for improvement. Sometimes, I don't even need to worry about profiling, as the program runs efficiently enough without the need to focus on microefficiency.
Newbie programmers can accomplish incredible things on their first day, and even greater things in the first week. However, within a month, they might encounter significant challenges and frustrations. In a professional setting, only senior programmers designing applications are typically concerned with resource allocations. Junior programmers are expected to write code as specified by their seniors. With Go, however, junior programmers can write code at an advanced level, possibly past their current level of expertise.
One of the most valuable aspects of Go is not the language itself, but the community surrounding it. The community is filled with people willing to assist those who are learning, providing code reviews, and sometimes suggesting examples of good co...
First of all, golang is a general-purpose programming language. Which means you could do almost anything in golang.
Because it is a general-purpose programming language, it’s easier to describe what you cannot do in golang. So here’s what golang is not (yet?) good at:
- Firmware and OS Kernel Development. In C, there’s a so-called freestanding environment, which expects nothing, really nothing in place. Firmware and OS kernels are typically written in C, using the freestanding environment.
- Desktop UI development. It can be done, but libraries to do that in golang aren’t that mature yet. The rock st
First of all, golang is a general-purpose programming language. Which means you could do almost anything in golang.
Because it is a general-purpose programming language, it’s easier to describe what you cannot do in golang. So here’s what golang is not (yet?) good at:
- Firmware and OS Kernel Development. In C, there’s a so-called freestanding environment, which expects nothing, really nothing in place. Firmware and OS kernels are typically written in C, using the freestanding environment.
- Desktop UI development. It can be done, but libraries to do that in golang aren’t that mature yet. The rock stars in this field are still C++/Qt, and Java with JavaFX.
- Web frontend. Golang can be compiled to JavaScript and Web Assembly, but I wouldn’t call that mature yet.
- Mobile App development. It can be done, but this also is relatively new, the rock stars in this field are still Java/Kotlin for Android, Objective-C/Swift for iOS, and for portable code, JavaScript with ReactNative.
- XML. There’s a lot of stuff going on with XML at publishers and elsewhere. Golang libraries for XML are primitive and implement only very old standards of XML. Here, Java is the industry leader, followed by C# and JavaScript, mostly because of Michael Kay’s Saxon.
- SOAP. In case you have to talk to a legacy SOAP system, it can be done, but it’s not as nice and comfortable as it would be in Java.
- Games. Golang has the speed, but not the libraries/support. That said, I am totally looking forward to Golang entering this space.
- Banking. The nature of the package management of Golang makes it difficult (but not impossible) to use it in a banking environment, where there typically is no direct internet access, and where each third party library can only be used after approval from a security department after performing a scrutiny process.
- Automotive, Aerospace, and Medical. These industries have a vast infrastructure of verification methods and tools which do not yet exist in Golang.
For all these limitations, it has to be said that it is possible to overcome these limitations, either with sufficient development power on your end, or by waiting until somebody else has done it. In many of these, I have seen development and evolution of third party libraries.
Also, it is easy to integrate Golang with C and all languages that made integration with C easy, like Python. Many programming languages, like Java, JavaScript have a strong disconnect from the native ABI (Application Binding Interface). For such languages, an interaction with Golang is difficult. For programming languages which are connected to the native ABI, interaction with Golang is very easy.
Apart from these, I haven’t found any serious limitations in Golang, and using it is fun. It has become one of my goto languages for command line tools and REST services (microservices and monoliths), a space in which for me it competes with Java, C, Perl, and occasional JavaScript.
Go is a lovely language with quirks, like every other language (Java, C#, JavaScript, Python, C, C++).
It simply isn’t.
More than that, I would say that it’s worse than some other languages:
- Its useability is very limited and some easy tasks in other languages, like operating on collections, is very hard in Go
- Being statically typed is not an advantage - half of the languages are statically typed. And being statically typed is also a limitation sometimes. Same for being compiled.
- It compiles fast, only if you use no external libraries nor dependency management system. Otherwise, its compile times are similar to many other languages.
- The concurrency is half-baked. Channels are always bounded. No way
It simply isn’t.
More than that, I would say that it’s worse than some other languages:
- Its useability is very limited and some easy tasks in other languages, like operating on collections, is very hard in Go
- Being statically typed is not an advantage - half of the languages are statically typed. And being statically typed is also a limitation sometimes. Same for being compiled.
- It compiles fast, only if you use no external libraries nor dependency management system. Otherwise, its compile times are similar to many other languages.
- The concurrency is half-baked. Channels are always bounded. No way to cancel a goroutine. No easy way to get a single result from a coroutine. Some other languages, like Kotlin, do that a lot better.
- Object-oriented stuff is also half-assed. You have structs, interfaces and ducktyping, which is actually a disadvantage when you work with bigger projects.
- There was no official package manager until recently. We went through dep/glide and I can think some others.
- It misses some very productive features such as generics and exceptions. It’s ok to have no exceptions when you write command line utility. It’s not good when you write some business logic.
- Web libraries are awful. Revel is basically dead. BeeGo is a collection of bugs, basically.
With the exception of one particular aspect of Go, I’m not sure that Go is better than all other existing languages. For the work that I’m involved in - back-end systems, instead of complex GUIs on the desktop, Go tends to be a better choice than other languages targeted at the same domain. Other languages targeting the same domain include Java and other JVM-based languages (Scala, Groovy), and others like Python, Ruby, and maybe Javascript. Others might toss in other languages like Clojure and Haskell, which I don’t have any exposure to, so I don’t know how they compare. I don’t think Rust is
With the exception of one particular aspect of Go, I’m not sure that Go is better than all other existing languages. For the work that I’m involved in - back-end systems, instead of complex GUIs on the desktop, Go tends to be a better choice than other languages targeted at the same domain. Other languages targeting the same domain include Java and other JVM-based languages (Scala, Groovy), and others like Python, Ruby, and maybe Javascript. Others might toss in other languages like Clojure and Haskell, which I don’t have any exposure to, so I don’t know how they compare. I don’t think Rust is a viable competitor in this space yet, because the available libraries are too few and not fully battle-tested.
Compared to that set of languages, here’s what I find in Go that is better:
- Explicit error handling is a huge boon for correct code. When I started with Java years ago, I enjoyed using exceptions. Over time, I discovered that using exceptions makes it easier to overlook possible failures, and makes it more difficult to identify good test cases that exercise all the scenarios that can go wrong. Go’s approach, when coupled with code coverage analysis, means complete clarity about which failure scenarios are not being exercised.
- The late binding of statically typed interfaces works dramatically better than the Java model. Python, Ruby, and Javascript can late bind to implementations due to duck-typing. Go brings the advantage of late-binding to interfaces at compile time. It is really easy to underestimate the value of Go’s really neat trick of implementing interfaces the way it does.
- Single executable deployment. Java 9 brings this feature into the mix, so possibly not really a true advantage any more.
- Careful use of memory layout. Go stores an array of structures as a contiguous chunk of memory. Other languages tend to wrap data up in objects, and pointers to objects. Go’s approach means that without too much work, it is easier to get the advantages of processor caches. Other languages I mentioned have made explicit design decisions that all but prevent ever getting close to Go’s value in this area.
- Careful use of memory allocation. Go’s escape analysis means that code that looks like it allocates memory might actually be storing data on the stack. Java perhaps does escape analysis better, but Go does escape analysis at compile time - which means that it is easier to check a specific package for escape analysis characteristics and improve it, rather than having to work on a whole program all at once.
- Opinionated formatting. It boggles the mind that this many years into programming, it can still be necessary to make white-space changes in order to minimize a code difference so that other team members know what happened.
- Designed for multi-core processors. All the other languages support multi-core processors, but Go does it better, using fewer resources to achieve the same ends. Not that I’m a huge fan of the concurrency approach that Go takes - it provides useful primitives, yet it is still possible to get it horribly wrong. In contrast, a language like Rust makes it hard to get horribly wrong. Go just makes it possible to exploit multi-core processors just a little bit better than other languages.
Given the languages targeting the same space - Java, Scala, Python, Ruby, and Javascript, Go isn’t really “better” than all those other languages in the ways that others have mentioned: compilation speed, concurrency support, package management, community and corporate support. Each of those other languages has some aspect that surpasses Go.
In my experience, there is *one* feature of Go that is simply better than all other languages out there, not just the ones targeting the same domain. In my experience, Go is the best language for context switching. Meaning that when I switch to coding from some other task, I can start making productive changes to Go code in less time than any other language. In my role, where I get to code only occasionally, this one aspect makes it possible for me to be a much more productive developer.
Is Go better than C++ and Python? It’s a subjective question, and it’s also a bit strange that it lumps C++ and Python together. C++ and Python are good in entirely different ways, and there are few tasks where one could use either language with equal ease.
What Go really is, at least in some ways, is a middle ground between Python and C++—It is good at some things C++ is good for, and it is good for some things Python is good for. It is also bad for some things C++ or Python would be good for, and there are a few things that it is better at than either of the others.
Things both Go and Python a
Is Go better than C++ and Python? It’s a subjective question, and it’s also a bit strange that it lumps C++ and Python together. C++ and Python are good in entirely different ways, and there are few tasks where one could use either language with equal ease.
What Go really is, at least in some ways, is a middle ground between Python and C++—It is good at some things C++ is good for, and it is good for some things Python is good for. It is also bad for some things C++ or Python would be good for, and there are a few things that it is better at than either of the others.
Things both Go and Python are good for:
- OS automation. Both are great languages for dev ops.
- Rapid development of small utilities.
- Backend web development—though each excels at this in a different way. Python is better for getting a small site up quickly and for leveraging featureful backend frameworks. Go is better for implementing high-performance backend APIs where the views are more likely to be rendered on the client.
- Both Python and Go have simple, minimal syntax that is easy to learn and use.
Things both Go and C++ are good for:
- General programming tasks where good performance is required.
- Well performing, high load network infrastructure.
- Systems programming—to some extent. There are aspects of the machine that abstracted away in Go that limit flexibility in some cases. More on that later.
Areas where Go is better than either Python or C++.
- Go software should generally be more reliable than software written in C++ or Python: Unlike C++, it is memory safe and garbage collected, and unlike Python errors must be explicitly dealt with. Unlike Python, types are explicit, and unlike C++, values can only be converted to other types, never simply cast to them. There’s less that can go wrong at runtime because Go is more strict at compile time than either.
- Go performance should be more predictable than Python, though not necessarily more predictable than C++. The Go runtime and compiler are fairly straightforward, and you can pass things by pointer or by copying the value as needed.
- Go was specifically designed to make high-performance concurrent applications easy to build, and it is much more advanced than either Python or C++ in this area.
Areas where Go is not as advanced as Python or C++:
- Go is less expressive than either. Go has essentially no metaprogramming story, whereas C++ has templates and Python has its metaclasses. Some might see this as a good thing.
- To date, Go still has no support for parametric polymorphism outside of a few built-in types. Maybe in Go 2?
- While Go slices and maps make it useful for a lot of basic tasks, it’s never going to match Python for rapidly prototyping something complex. By design, Go is more deliberate and explicit, so programmers have to make certain decisions up front that could be postponed in Python.
- Go has reasonably good performance, but it is not nearly as tunable as C++. Concurrency in Go will be both simpler and faster than any simple solution you would come up with in C++, but it’s not very tweak-able. If you write a purpose-specific scheduler for your task, it’s probably going to beat Go. Likewise, for implementing something like an operating system, Go’s garbage collection and less direct access to memory are only going to get in the way.
- Go’s ecosystem is impressive for the age of the language, but it isn’t anything close to what Python or C++ can offer. Go has little to offer for numeric computing, machine learning, GUI application development, graphics libraries, etc.
Not at all!
Go was designed at Google in 2007 to address the efficiency of C and motivated to improve some of the qualities of C++. On the one hand, the main purpose of the language was relative simplicity attained by omitting some of the features that are common in similar languages. On the other hand, it was built with preserving their most useful characteristics in mind, such as static-typing and run-time efficiency, readability and usability, high-performance networking, and multi-processing. Go has quickly become the standard language for the new generation of coders at Google.
According to
Not at all!
Go was designed at Google in 2007 to address the efficiency of C and motivated to improve some of the qualities of C++. On the one hand, the main purpose of the language was relative simplicity attained by omitting some of the features that are common in similar languages. On the other hand, it was built with preserving their most useful characteristics in mind, such as static-typing and run-time efficiency, readability and usability, high-performance networking, and multi-processing. Go has quickly become the standard language for the new generation of coders at Google.
According to Go Developer Survey 2020, Golang usage is expanding in the workplace and enterprise with 76% of respondents using Go at work, and 66% saying Go is critical to their company’s success. Furthermore, Go continues to be heavily used for APIs, CLIs, Web, DevOps, and Data Processing. One of the cases where Go has shown excellent results is bidding in real time.
I hope my answer helped you!
I have been writing software in Python for 12 years and started coding in Go 2 years ago... Go is such a great tool, I can easily see it become more popular than C++, Java, Python and Ruby in ten years from now.
Python is becoming (already is ?) more popular than C++ or Java because its more productive and more "fun". That's also the reason Ruby exists. However, as any sufficiently experienced python programmer will tell you, eventually Python's crappy performance will hit you in the face. And improving the execution speed of a Python program tends to make it uglier and uglier (Cython, C exten
I have been writing software in Python for 12 years and started coding in Go 2 years ago... Go is such a great tool, I can easily see it become more popular than C++, Java, Python and Ruby in ten years from now.
Python is becoming (already is ?) more popular than C++ or Java because its more productive and more "fun". That's also the reason Ruby exists. However, as any sufficiently experienced python programmer will tell you, eventually Python's crappy performance will hit you in the face. And improving the execution speed of a Python program tends to make it uglier and uglier (Cython, C extensions etc.). Go hits just the sweet spot of Java-like speed with almost pythonic productiveness. Most of the new Go programmers are coming from a Python and Ruby background just because of that.
The built-in concurrency and the fact that Go has no type hierarchy is just icing on the cake (Type hierarchy in OOP tends to make your programs more complex than they should be and does not scale well).
Go is already used in production at various companies (most of SoundCloud's infrastructure is written in Go, IIRC). And there already is a Killer App: it's called Docker (Docker: the Linux container engine).
I think Go is reasonably fast to learn and is a great tool to add to your arsenal. I sure am glad I learned it.
Not only is Go going to become a mainstream language - it's going to become *the* mainstream language. Go is in route to become the next great language.
I believe in the coming years (<2 yrs) most ruby shops are going to move towards go.
Ruby allows the more jr developers to shoot themselves in the leg way too much and in terms of resources it's a total memory hog and kills the cpu so your aws bill for a startup that is actually serving requests is out of control.
Ruby is a financial liability in comparison to go.
I also believe in the coming years many enterprise shops are going to move away from
Not only is Go going to become a mainstream language - it's going to become *the* mainstream language. Go is in route to become the next great language.
I believe in the coming years (<2 yrs) most ruby shops are going to move towards go.
Ruby allows the more jr developers to shoot themselves in the leg way too much and in terms of resources it's a total memory hog and kills the cpu so your aws bill for a startup that is actually serving requests is out of control.
Ruby is a financial liability in comparison to go.
I also believe in the coming years many enterprise shops are going to move away from java towards go.
We've seen this happen just in the past couple of years - we aren't talking about engineering focused companies - we are talking about fortune 500 companies (banks, oil companies, car manufacturers) These are big companies that don't have software as a core but they are so big they have to have development teams.
Already they are starting to build out services in go - it's only a matter of time before it overtakes the JVM.
In short go is going to become the number one language to write (especially HTTP) services in.
It really goes beyond developer preference but I'm meeting more and more of the shops that engineers would want to work for being go shops versus social-local-mobile-blah being more Ror shops.
The last go meetup here in SF had 280 people that 'went' (reserved). Go core team members routinely show up.
All the super hyped companies right now - coreos/docker/sourcegraph - they are using go.
Other well knowns - cloudflare, 10gen, digitalocean, sendgrid, heroku, square, etc.
In terms of tooling, speed of development - when you have things like pilu/fresh && fatih/vim-go - I actually feel faster writing go than I would writing ruby and I don't think it needs to be said that it's *much* faster than developing w/{java,scala,clojure} .
Also - it's not just for systems programming - this is something I hear a lot but it's totally untrue. Most shops I know that use go heavily use it for APIs - it is becoming the de facto for in-house backend API development. I predict that if you are hired for 'backend' development in SF in the next 1.5 -> 2 yrs it'll be for writing in go. No joke.
Android support started really rearing it's head in 1.4 so you know that the big G is a great position to evangelize that and alleviate their oracle woes.
We (Defer Panic) so strongly believe that go will overtake the JVM and RoR that we are soley focusing on developing the tooling in this new ecosystem.
The future is Go.
It's a fairly easy-to-use, compiled, garbage-collected language with a strong ecosystem. Why that's important:
- Compiled - performance and (a little bit of) source safety (i.e. it's hard for people to read your sources if you want to preserve intellectual property). Plus it's not super-hard to interface with C libraries of for some reason you need a weird one.
- Garbage-collected - unlike languages like C, you don't generally have to do huge amounts of memory management on your own.
- Strong ecosystem - thanks to Google's support, the HTTP library is stellar and the rest of the standard library (and t
It's a fairly easy-to-use, compiled, garbage-collected language with a strong ecosystem. Why that's important:
- Compiled - performance and (a little bit of) source safety (i.e. it's hard for people to read your sources if you want to preserve intellectual property). Plus it's not super-hard to interface with C libraries of for some reason you need a weird one.
- Garbage-collected - unlike languages like C, you don't generally have to do huge amounts of memory management on your own.
- Strong ecosystem - thanks to Google's support, the HTTP library is stellar and the rest of the standard library (and the extended ecosystem, like individual contributions on GitHub) are very easy to integrate.
- Easy-to-use - unless you like being difficult :-)
It's a great toolbox to use for solving many problems. Not all, but many. If I were starting to learn programming today, I'd probably pick Go for backend services, JavaScript for web ui, and shell scripting for one-off automation. Doing that with App Engine and git for source control is a potent combo.