Ardan Labs Blog

Ardan Labs | Mid - Senior Software Engineer | Miami, FL | Full Time | REMOTE | ONSITE | https://www.ardanlabs.com/ Ardan Labs is a high performance software development firm that builds and delivers reliable solutions and applications. We're looking for several Mid-level and Senior Backend Engineers to help us develop solutions for our clients. This is a great opportunity to be part of a culture of caring, cooperation, reliability and growth. We are based in Miami, Florida, but our team is spread across North America. Some roles may be location dependent, but we welcome remote work. Ideally you are a responsible, self-motivated individual that is looking to work with the latest technology and create uncompromising user experiences. Responsibilities: Design and build REST/gRPC APIs with speed and reliability in mind. Design and use SQL and NoSQL databases to support both relational and nonrelational performance and storage requirements. Write tests. Document web services for public consumption. Implement proper instrumentation and logging. Leverage Kubernetes/Docker to deploy and manage a scalable infrastructure across multiple geographical regions. Respond to system level issues as necessary to provide the best overall customer experience. Qualifications: Minimum 2+ years of professional experience developing REST based web services. Experience developing in more than one backend language preferrably Go, C/C++, Java, Ruby, Python, Node.js, etc. Experience with the…

Counter-point: developing web services in Rust is just as easy as doing it in Go or Java, yet you now have an excellent type system (sum types!), an excellent package manager, and extremely good performance. You can do dependency injection in Rust to share connection pools just like you would in Java, and it's super simple to write threaded background tasks. Google gave a talk recently that said they measured Rust developers as no less efficient or productive than Go developers [1]. It's a fantastic language and you shouldn't ever limit yourself to systems programming with Rust. It can do so much more than that. [1] https://www.ardanlabs.com/news/2024/rust-at-google/

Probably, here is the link to the full bundle https://www.ardanlabs.com/training/ultimate-go/#tabpanel and this was the course I was talking about https://www.ardanlabs.com/training/ultimate-go/advanced-concepts/ Indeed $700 is a steep price(I live in Eastern Europe so it looks even steeper), but for me it worth it as it helped me a lot in interviews which landed me nice paying jobs(by my standards). I don't know how long it would have taken me to learn all those concepts by myself. The value of a good course is that it condenses the time you need to learn something and this course did the job. There is also Ultimate Go notebook which is just $10[1], the notes from this course. If the course is too expensive I would go with that. [1] https://www.ardanlabs.com/ultimate-go-notebook/

Ardan Labs | Multiple positions | REMOTE | https://www.ardanlabs.com/ Ardan Labs helps teams become effective with Go, Docker & Kubernetes. We work with startups & Fortune 500 companies to help their engineering teams become better developers, code reviewers, designers and architects. Open Positions: - Mid-level/Senior Backend Engineers with Go experience - DevOps Engineer - Data Engineer - Infrastructure Engineer - Blockchain core developer Benefits: - Access to our live & online courses in Go, Docker, Kubernetes & more. - Benefit from the knowledge of your coworkers working across industries on different projects. - Private talks for the team from popular people & projects in the industry. - As a W2 employee, we offer family medical coverage, life insurance, paid vacation, and technical training. Apply here: https://www.ardanlabs.com/my/careers

William Kennedy has an excellent post on this https://www.ardanlabs.com/blog/2017/06/design-philosophy-on-data-and-s… As someone who has written (and read) a decent amount of Go the value vs pointer semantics of the function informs me of how the creator intends for the type to be used. Seeing pointer receivers informs me that there is an expectation of modifying the state while value pointers (which are thankfully more common) return a copy of the data.

My guess is you are incorrect and this has more to do with the Ardan Labs partnership[1][2]. This release also came shortly after Bill (founder of Ardan Labs) went to visit Matt and discuss Caddy[3], which helps support that claim. Prior to the partnership I believe the real issue was that Matt & co didn't have a sustainable way to maintain the project and they were trying to figure that out. I don't know the details of the partnership with Ardan Labs, but my guess is it is structured in a way that allows Caddy to focus solely on building out a great product without worrying about monetizing it so they dropped all the proprietary licensing. [1] - https://www.ardanlabs.com/news/2019/05/ardan-labs-partners-with-caddy.… [2] - https://twitter.com/mholt6/status/1179957356005707776 [3] - https://twitter.com/goinggodotnet/status/1178949305421438976

Not necessarily a collection of beginner tutorials, but for what they're worth, these are some very high quality in-depth articles on pieces of the language: - https://dave.cheney.net/practical-go - https://www.ardanlabs.com/all-posts/ If you're looking for more high-level, "get-things-done" stuff, this has been a great resource for getting off the ground: - https://github.com/astaxie/build-web-application-with-golang

This is a myth pushed by the "Choose Boring Technology" cult [1] and proven false by Google [2]. [1]: https://boringtechnology.club/ [2]: https://www.ardanlabs.com/news/2024/rust-at-google

I am aware of epoll_wait and friends (select/poll) accepting timeouts, and how that plugs into a general event loop like in libuv. However if memory serves, these calls are reasonably expensive (on the order of microseconds, and _worse_ if readiness requires putting the current thread to sleep and then waking it up again). However https://www.ardanlabs.com/blog/2018/08/scheduling-in-go-part2.html says goroutines are closer to 200ns. However the same source above does a decent job of explaining how epoll is being called "out of band". I am guessing when they talk about context switching costs, they are doing some sort of amortization of these system call costs. Since the actual OS threads try to remain CPU-affine (thread-per-core, LMAX disruptor etc. etc.), a lot of the OS scheduling costs can be skipped. Thank you for the pointer to the source code. It gives me a starting point.

Not necessarly, .NET and D have a much better interop story, despite having runtimes. You can certainly publish lib.so with Go, here is an example, https://www.ardanlabs.com/blog/2020/07/extending-python-with-go.html

> So if you learn Go, you'll never be able to use it to interoperate with e.g. your Python program to speed it up. Never done it myself, but: https://www.ardanlabs.com/blog/2020/07/extending-python-with-go.html https://github.com/go-python/gopy

The original url was put back https://www.ardanlabs.com/news/2020/08/caddy-server-is-acquired/

It seems Ardan Labs changed the url to https://www.ardanlabs.com/news/2020/08/caddy-server-acquired-by-apilay…

For that, you will need to know a bit about Go. The full totorial is here https://www.ardanlabs.com/blog/2014/03/exportedunexported-identifiers-… So in the end there's really no trick, you still can't access them directly.

You should look into multistage docker builds, that lets you still use a full fat image for your build but then leave all the build tools out of your final image I liked jpetazzo's post on the subject but there are plenty to choose from https://www.ardanlabs.com/blog/2020/02/docker-images-part1-reducing-im…

I worked (a long time ago) on Burroughs mainframes which did bounds checking of arrays (and in fact even type checking), because the whole machine was build around ALGOL. I am not sure whether the experience from these machines was negative. It may be that when you move beyond one-dimensional arrays, bounds checking becomes more complicated. Perhaps performance suffers too. Languages which do bounds checking often have intelligent compilers which can skip the bounds check in a variety of conditions. So even if the hardware is faster, it may be doing unnecessary checks. See for example : https://www.ardanlabs.com/blog/2018/04/bounds-check-elimination-in-go.…

You are right, see Synchronous System Calls in https://www.ardanlabs.com/blog/2018/08/scheduling-in-go-part2.html

Sorry, I completely disagree. I don't consider mere M:N thread work distribution as anywhere close to what the go scheduler offers. This article mentions some of the fundamental problems with core.async: http://danboykis.com/posts/things-i-wish-i-knew-about-core-async/ Having to pay ridiculously careful attention to what code blocks across libraries and function boundaries is something that golang completely takes away the need for - because it has a true cooperating scheduler built into the runtime at the boundary of every syscall. Decision making is in hands of the Go runtime. You can write in standard dumb sync fashion at 3am in the night within a go-routine making all the Go library calls you wish to make without needing to scan code with a microscope to see what blocks and what doesn't. https://www.ardanlabs.com/blog/2018/08/scheduling-in-go-part2.html core.async is a half-baked error prone solution. People will make mistakes with it. Until the JVM has native support for fibers, continuations and a compile mechanism to classify all legacy blocking calls as unsafe, core.async will continue to be hobbled.