Hey, you are actually double booked for the nth meeting for annual “Goals” that’s coming up!
The misconception that we’re the person to go to to fix your printer…
..I mean we probably can fix it, but it’s a waste of our time…
I’m not crazy about Google’s part in Go, but man, I’ve been using Go a lot and I love it. It feels like a “modern C” that lets you focus on logic instead of memory allocation. I know it violates your requirements, but I’d suggest checking it out anyway! 🤷♂️
I feel your pain. I once worked at a place that hired an “expert” as a senior dev who asked me on the first day, “what is this import on the first line of this code??? I’ve never seen this before. 🤔” They were unfamiliar with the concept of packages and importing them… Senior dev, hired specifically because they were an expert in a specific language…
They’d call me upwards of 12 times a day for help with the most basic of tasks with anything technical, to include how to install the basic runtime to be able to run code in that language.
(I’m speaking quasi cryptically on purpose.)
Not sure why downvoted. HTMX does seem to be becoming popular. I prefer the simplicity of it.
WASM is simply further down the rabbit hole for someone who is new to programming (but not someone who’s already a programmer and just doesn’t focus on web dev today). You are likely far less beginner than you think if you’re making decisions like “I’m going to compile my software written in Rust targeting WASM so I can demo it.”
Python, and dynamically typed languages in general, are known as being great for beginners. However, I feel that while they’re fun for beginners, they should only be used if you really know what you’re doing, as the code can get messy real fast without some guard rails in place (static typing being a big one).
Degrees are meaningless
my own CS degree taught me almost nothing
I think you meant that your degree was meaningless?
I concur, it is a problem with that workplace. (In this case, OP is just sharing a funny meme. I wouldn’t suggest this meme means they’re a problem. I could have made this meme and I love the feature.)
Developing on a team at a company is like the “Wild West.” What’s considered to be acceptable will not only vary from workplace to workplace, but it can also fluctuate as developers and managers come and Go. Each of them have their own unique personality with their own outlook on what “quality” code looks like. (And many of them do not care about code quality whatsoever. They just need to survive 1-2 years there, make management happy with speedy deliveries, and then they can move on to the next company with a 30% pay bump.)
Having experienced working with developers who frequently filled with code base with unused code while having no control over who will leave or join as a contributor to the code base, I think features like this make for a more sane development experience when you’re developing with a team of seemingly random people that you never personally invited to contribute to the code base.
will not merge your PR unless the stricter rules are met.
This doesn’t fly when you work in big corporate and the boss doesn’t care about the code meeting stricter rules. “A working prototype? No it’s not- that’s an MVP! Deploy it to production now and move onto the next project!”
If this language feature is annoying to you, you are the problem. You 👏are 👏 the 👏 reason 👏 it 👏 exists.
I worked in places where the developers loaded their code full of unused variables and dead code. It costs a lot of time reasoning about it during pull request and it costs a lot of time arguing with coworkers who swear that they’re going to need that code in there next week (they never need that code).
This is a very attractive feature for a programming language in my opinion.
PS: I’m still denying your pull request if you try to comment the code instead.
❗️EDIT: A lot of y’all have never been to programming hell and it shows. 🪖 I’m telling you, I’ve fixed bayonets in the trenches of dynamically typed Python, I’ve braved the rice paddies of CICD YAML mines, I’ve queried alongside SQL Team Six; I’ve seen things in production, things you’ll probably never see… things you should never see. It’s easy to be against an opinionated compiler having such a feature, but when you watch a prod deployment blow up on a Friday afternoon without an easy option to rollback AND hours later you find the bug after you were stalled by dead code, it changes you. Then… then you start to appreciate opinionated features like this one. 🫡
Anyone know off hand if this can pass values returned from one step into another step as arguments?
I’ve found Docker helpful when I want to use it to build binaries or use CLI tools that may not be available directly on the CICD platform. Also, Docker makes it easier to run the same code on MacOS that I ended up running on a Linux CICD server.
What would you consider to be overuse of containers?
Most of those things mentioned aren’t bona fide needs for me. Once a developer is deploying their project, they’re watching it go through the pipeline so they can quickly respond to issues and validate that everything in production looks good before they switch contexts to something else.
I see what you’re saying though, depending on what exactly is being deployed, the policies of your organization, and maybe expectations that developers are working in another context once they kick off a deployment, it could be necessary to have alerting like that. In that case it may be wise to flex some features of your CICD platform (or build a more robust script for deployment that can handle error alerting, which may or may not be worth it).
Voyager — a mobile-first Lemmy web client (formerly wefwef) - GitHub - aeharding/voyager: Voyager — a mobile-first Lemmy web client (formerly wefwef)
Voyager, aka ‘wefwef.app’, just hit 1.0
This is a project that makes me really interested in what I can do with a PWA.
(It’s an Apollo-esque (an iOS app for Reddit) progressive web app for Lemmy, and it kicks ass so far.)
Yaegi is Another Elegant Go Interpreter. Contribute to traefik/yaegi development by creating an account on GitHub.
I’ve been using this to execute Go “scripts” in CI pipelines where Bash just doesn’t cut it. It’s an interpreter for Go. It can be used to treat Go code like a “script,” rather than a compiled application. It is also able to be imported into a Go program and used to load up Go code dynamically at run time (think “loading plugins” with Go!).
From the readme:
[!release](https://github.com/traefik/yaegi/releases) [!Build Status](https://github.com/traefik/yaegi/actions/workflows/main.yml) [!GoDoc](https://pkg.go.dev/mod/github.com/traefik/yaegi)
Yaegi is Another Elegant Go Interpreter. It powers executable Go scripts and plugins, in embedded interpreters or interactive shells, on top of the Go runtime.
Features
- Complete support of [Go specification][specs]
- Written in pure Go, using only the standard library
- Simple interpreter API:
New(),Eval(),Use() - Works everywhere Go works
- All Go & runtime resources accessible from script (with control)
- Security:
unsafeandsyscallpackages neither used nor exported by default - Support the latest 2 major releases of Go (Go 1.19 and Go 1.20)
Install
Go package
go import "github.com/traefik/yaegi/interp"
Command-line executable
bash go install github.com/traefik/yaegi/cmd/yaegi@latest
Note that you can use rlwrap (install with your favorite package manager),
and alias the yaegi command in alias yaegi='rlwrap yaegi' in your ~/.bashrc, to have history and command line edition.
CI Integration
bash curl -sfL https://raw.githubusercontent.com/traefik/yaegi/master/install.sh | bash -s -- -b $GOPATH/bin v0.9.0
Usage
As an embedded interpreter
Create an interpreter with New(), run Go code with Eval():
```go package main
import ( "github.com/traefik/yaegi/interp" "github.com/traefik/yaegi/stdlib" )
func main() { i := interp.New(interp.Options{})
i.Use(stdlib.Symbols)
_, err := i.Eval(import "fmt")
if err != nil {
panic(err)
}
_, err = i.Eval(fmt.Println("Hello Yaegi"))
if err != nil {
panic(err)
}
}
```
As a dynamic extension framework
The following program is compiled ahead of time, except bar() which is interpreted, with the following steps:
- use of
i.Eval(src)to evaluate the script in the context of interpreter - use of
v, err := i.Eval("foo.Bar")to get the symbol from the interpreter context, as areflect.Value - application of
Interface()method and type assertion to convertvintobar, as if it was compiled
```go package main
import "github.com/traefik/yaegi/interp"
const src = package foo func Bar(s string) string { return s + "-Foo" }
func main() { i := interp.New(interp.Options{})
_, err := i.Eval(src) if err != nil { panic(err) }
v, err := i.Eval("foo.Bar") if err != nil { panic(err) }
bar := v.Interface().(func(string) string)
r := bar("Kung") println(r) } ```
As a command-line interpreter
The Yaegi command can run an interactive Read-Eval-Print-Loop:
console $ yaegi > 1 + 2 3 > import "fmt" > fmt.Println("Hello World") Hello World >
Note that in interactive mode, all stdlib package are pre-imported, you can use them directly:
console $ yaegi > reflect.TypeOf(time.Date) : func(int, time.Month, int, int, int, int, int, *time.Location) time.Time >
Or interpret Go packages, directories or files, including itself:
console $ yaegi -syscall -unsafe -unrestricted github.com/traefik/yaegi/cmd/yaegi >
Or for Go scripting in the shebang line:
```console $ cat /tmp/test #!/usr/bin/env yaegi package main
import "fmt"
func main() { fmt.Println("test") } $ ls -la /tmp/test -rwxr-xr-x 1 dow184 dow184 93 Jan 6 13:38 /tmp/test $ /tmp/test test ```
Documentation
Documentation about Yaegi commands and libraries can be found at usual [godoc.org][docs].
Limitations
Beside the known [bugs] which are supposed to be fixed in the short term, there are some limitations not planned to be addressed soon:
- Assembly files (
.s) are not supported. - Calling C code is not supported (no virtual "C" package).
- Directives about the compiler, the linker, or embedding files are not supported.
- Interfaces to be used from the pre-compiled code can not be added dynamically, as it is required to pre-compile interface wrappers.
- Representation of types by
reflectand printing values using %T may give different results between compiled mode and interpreted mode. - Interpreting computation intensive code is likely to remain significantly slower than in compiled mode.
Go modules are not supported yet. Until that, it is necessary to install the source into $GOPATH/src/github.com/traefik/yaegi to pass all the tests.
Contributing
License
[Apache 2.0][License].
[specs]: https://golang.org/ref/spec [docs]: https://pkg.go.dev/github.com/traefik/yaegi [license]: https://github.com/traefik/yaegi/blob/master/LICENSE [github]: https://github.com/traefik/yaegi [bugs]: https://github.com/traefik/yaegi/issues?q=is%3Aissue+is%3Aopen+label%3Abug
>OrbStack is a fast, light, and simple way to run Docker containers and Linux machines on macOS. You can think of it as a supercharged WSL and Docker Desktop alternative, all in one easy-to-use app.
I just caught wind of this and have yet to try it. Does anyone here have any experience with OrbStack that they can speak to? 👀
