ivan4th

kubectl port-forward my-lisp-pod 4005:4005

then M-x slime-connect localhost 4005

There's another jsonnet tool called qbec that can do that - https://qbec.io

I see it this way (being a Russian): it's not a copyright claim issue, but rather a hostage situation with bandits involved (a.k.a Russian authorities), and what they want is ransom so that top #1-2 nginx contributors don't go to jail for some 10 years.

The complaints about Lisp parentheses sound especially funny in the context of that kind of mainstream DevOps tooling https://github.com/helm/charts/blob/eceb82f6308578b824d58f80... (EDIT: yep, I'm a Lisp fan and a Kubernetes guy at the same time, and this kind of templating is like worst kind of "blasphemy" for me :)

One possibility (especially for "home Kubernetes" case) is not exposing the services to the outside world at all and using ZeroTier to access them https://www.zerotier.com/ It's L2 mesh VPN, and I believe you can even use MetalLB with it with some minor trickery. You can, of course, set up WireGuard or OpenVPN for yourself, too, but from my experience zt is the simplest for accessing the boxes behind NAT as you don't even need to set up any servers with real IPs.

Good for you! I've lost most of my "childhood coding" stuff to an accidental `rm -rf /home /something` (note the extra space. Backups? what backups?) some ~18 years ago. That included a couple of DOS viruses, one of which was polymorphic (I wrote them just for fun and never spread them; did upload one to an antivirus vendor BBS back then through their "Submit a new virus" function and it's still in many databases because of that); a C++ rewrite of mars.exe voxel landscape generator, but with added rotation, music and lakes; a PWM-based WAV player for PC speaker; etc. I'm still quite sad about that accident ...

From my experience, while YAML itself is something one can learn to live with, the true horror starts when people start using text template engines to generate YAML. Like it's done in Helm charts, for example, https://github.com/helm/charts/blob/master/stable/grafana/te... Aren't these "indent" filters beautiful?

If you want to have a thriving community around your software and have bazaar-style development process, you better go with mainstream languages (C, C++, Go, Rust, Python, Java, etc.) The community is a great thing as projects like Linux and Kubernetes can show us. Yet there can be situations where you're the single developer on the project, or there are just 2-3 devoted hackers doing all the coding and for a variety of reasons there are little chances of inviting more people to join (niche projects ... closed projects w/o too much funding ... or maybe you're just not a good community builder). From my experience, Common Lisp with all its power is a perfect language for the latter situation. For me, it's also "thinking" language, as you can do exploratory programming easily compared to other modern languages. Source: I've built a control system for industrial electron accelerators using Common Lisp.

cl-async works pretty well with SLIME if you use its SLIME REPL integration feature that I contributed several years ago. https://github.com/orthecreedence/cl-async/blob/master/src/r...

It basically starts an event loop in a separate thread and then wraps all of the SLIME's evals so they're executed from within that event loop.

One possibility that I can see is generating code that will run on microcontrollers. While there are some LLVM+microcontroller experiments, I'd say this is probably not an easy way to go. And trying to run some kind of Lisp on a microcontroller will also only get you so far.

Well, I did write quite a bit of CL code for money, but it's hard to get paid for reimplementing every library that one may need in CL ;(

From my experience, Docker helps quite a bit with CL stuff in many cases. When you use some shared libs via CFFI, things can get fragile quick, start depending on a particular shared library version on the host system etc. So your app, for instance, works fine on Debian jessie, then you have to upgrade your host system to stretch and oops, it broke here and there. You update your quicklisp dist to fix shared lib incompatibility problem and oops again, you need a week to fix stuff that broke (this reflects some problems with CL library management, too), but you need to have your app up and running on the new system yesterday. If you wrap your CL app in a Docker image, you can continue running it on the prev distro version till you fix it to be compatible with the newer one. And that's just one example.

There used to be a catch, though, don't know if it's already fixed. If you use this ssh debugging feature you make your secrets world-accessible (anyone can connect to ssh and grab them). This was one of the reasons why I switched to CicleCI, actually (besides their Workflows).

Cool technology. Yet, no Emacs support yet... oops :(

One advice concerning adding the tests for legacy code (which may also help with partial rewrite later if it's judged to be necessary): golden master tests. Google it.

Second that. I did write production Common Lisp code and loved it. I've used various languages over the years, including Perl, C, C++, C#, JavaScript and Python (and Pascal, Basic and x86 assembly to some degree, too), and I mostly write Go code nowadays (Kubernetes-related stuff). Still, none of these languages or their environments matched the Common Lisp coding experience with plain Emacs and SLIME.

These particular pieces may not be dangerous, but some other pieces people could find could be with a higher level of contamination. https://en.wikipedia.org/wiki/Unsymmetrical_dimethylhydrazin...

BTW asked our guide if any of his acquaintances were scavenging this stuff, he said smth like "some did... all of them are already dead"

Some of the pics I took in that place (in the mountains & taiga near Lake Teletskoe): http://i.imgur.com/2DwEDg5.jpg http://i.imgur.com/3ISH2C9.jpg http://i.imgur.com/1ymYIbk.jpg http://i.imgur.com/Vl1pmIz.jpg

Yeah... I'm a diehard Common Lisp user, and when I saw YAML+go-template used for Kubernetes Helm templates, with some extra hacks to take care of indentation shifts... I felt almost physical pain.

I wrote a somewhat similar tool for use with Emacs many years ago, SwankJS: https://github.com/swank-js/swank-js See this demo, for example: http://emacsrocks.com/e11.html It was not dependent on Chrome features and even did work with IE6 at some point. Too bad REPL-based programming is not very useful for modern JavaScript. There's a successor, though: https://github.com/skeeto/skewer-mode

Besides using kubectl to manage VMs, you also get VMs that join the cluster network as first-class citizens. In this blog post you can see a k8s service pointing to a VM and accessing k8s services from within the VMs. Also, compared to EC2 / GCE / etc., you can use Virtlet for bare metal on-prem clusters, too.

Yes, you can use KubeVirt for Windows. In some cases, it may be even better than Virtlet for that purpose. But if you want a real Kubernetes Deployment / StatefulSet / DaemonSet / etc. built out of VMs (examples being unikernels, nested Kubernetes cluster for testing etc.) Virtlet may be a better choice.

You can't have a StatefulSet of VMs on KubeVirt, although you may want one if you're using unikernels or want to run a nested Kubernetes cluster for testing, like here: https://github.com/Mirantis/virtlet/blob/master/examples/k8s... On the other hand, you can't have VM migrations with Virtlet.

One of the most important changes in Go 1.10: Go is now suitable for working with the containers! Hooray!

What I mean here is that this problem is finally fixed: https://www.weave.works/blog/linux-namespaces-and-go-don-t-m... GH issue: https://github.com/golang/go/issues/20676 The fix itself: https://go-review.googlesource.com/c/go/+/46033 Relevant part of the release notes: https://golang.org/doc/go1.10#runtime

AFAIK you can run your own ZeroTier controller for free. It's just not documented too well and also it's missing the web UI for managing your networks.

I was looking forward to the fix for the dreaded Linux namespace handling problem: https://www.weave.works/blog/linux-namespaces-and-go-don-t-m... which kind of makes Go suck for many important container-related tasks. But apparently the effort has stalled... https://go-review.googlesource.com/c/go/+/46033

It should work quite well on Mac. Hyperkube runs on inner docker.

Although the project doesn't aim to replace Minikube, it can help a lot if you work either on Kubernetes itself or a project that extends Kubernetes, or want to give k8s a quick try. For example, you can start Kubernetes 1.5 cluster like this:

  $ wget https://cdn.rawgit.com/Mirantis/kubeadm-dind-cluster/master/fixed/dind-cluster-v1.5.sh
  $ chmod +x dind-cluster-v1.5.sh
  $ ./dind-cluster-v1.5.sh up

Unfortunately NaN behavior seems to be hard-wired in encoding/json code. The proper way to fix it is perhaps taking encoding/json sources and converting marshalling/unmarshalling code to use go-duktape Push/To/etc. functions instead of JSON writing/parsing. That's indeed a sizable amount of work, though.

As of integrating (some of) changes from my fork to the go-duktape mainline, thanks a lot! Didn't get around to do it myself.