spec VS devpod

Hi, Lapdev dev here. Let me try to answer your question.

It's installed on a remote server so it provides remote environments. If you use VSCode remote, then you can "open" it through VSCode remote ssh.

The environment that Lapdev provides essentially is a container (other format is on the roadmap) with things pre-installed as defined in Devcontainer(https://containers.dev/) format.

Happy to take this one, as I am one of the cofounder of Daytona.

Daytona solves all the automation and provisioning of the dev environment, actually wrote an article here laying out exactly what we do: https://www.daytona.io/dotfiles/diy-guide-to-transform-any-m...

Daytona currently supports only the dev container (https://containers.dev/) "dev env infrastructure as code" standard, but are looking to support others such as devfile, nix and flox.

Hope this helps

The full usage of the container means that you'll do the development inside the container. All the tools for development need to be installed inside the container. One of the technologies that leverage this approach is Devcontainers.

Two standards for CDE configuration exist: devfile.yml and devcontainer.json. Both assume that the CDE is a single container and allow specification of which tools should be deployed to this container, as well as a reference to scripts that should run after the container has been created.

... is how I introduced the concept of dev containers in my last article.

How it works? Dev Containers is a specification based on Docker. This specification describes a metadata file (devcontainer.json), which defines how the project (Docker container, IDE settings, plugins, etc) is set up.

Codespaces is built to run Dev Containers, an open standard for Development Containers. The Dev Container will reference a Docker build file, which describes the software and services our app is running on. It also defines things related to our development environment, including IDE plugins, network ports, and more.

I was using Devcontainer with VS Code. In a part of the container build process, DNS lookup seemed to be failing in Debian 12. BTW, the container image was based on Debian 11. I probably tried it about 10 times in total, so I'm pretty sure it persisted, not an one time error. I noticed the build process was failing because the process failed to find some domains, with an error message like could not resolve host github.com. Some domains I noticed was github.com and ghcr.io, so it failed sometimes for one domain, and sometimes for the other.

// For format details, see https://aka.ms/devcontainer.json. For config options, see the // README at: https://github.com/devcontainers/templates/tree/main/src/typescript-node { "name": "Node.js & TypeScript", // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile "image": "mcr.microsoft.com/devcontainers/typescript-node:1-20-bullseye", // Features to add to the dev container. More info: https://containers.dev/features. // "features": {}, // Use 'forwardPorts' to make a list of ports inside the container available locally. "forwardPorts": [8081], "initializeCommand": "bash .devcontainer/initializeCommand.sh", // Use 'postCreateCommand' to run commands after the container is created. "postCreateCommand": "bash .devcontainer/postCreateCommand.sh", // Configure tool-specific properties. // "customizations": {}, // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root. // "remoteUser": "root", // "containerEnv": { // }, // "remoteEnv": { // "DEV_USER_HOST": "${localEnv:USERNAME}" // }, "runArgs": ["-p=8081:8081", "--env-file", ".devcontainer/.env"] }

When you push your code to Github, you can develop the app using codespace and it will automatically set up an online development environment for you. Other tools will make your life easier when developing using a dev container e.g. DevPod.

DevPod is that new kid in town that works on the same standard of devcontainers.json that Codespaces uses but is on the infrastructure of your choice and is open source. The project was just launched this May and has gathered more than 5.3K stars in this period. The advantage is the lower costs (around 5-10 times cheaper than cloud VMs) with auto-shutdown.

For students, unless there are allocated server resources with network access, it SHOULD/MUST scale down to one local offline ARM64 node (because school districts haven't afforded containers on a managed k8s cloud for students at scale fwiu, though universities do with e.g. JupyterHub and BinderHub [4] and Colab).

For Chromebook sysadmins, Instructors, and Students learning about how {Linux*, ChromiumOS, Android, Git, Bash, ZSH, Python, and e.g. PyData Tools supported by NumFOCUS} are developed, for example;

When you git commit to a git branch, and then `git push` that branch to GitHub, and create a Pull Request, GitHub Actions runs the (container,command) tasks defined in the YAML files in the .github/workflows/ directory of the repo; so `git push` to a PR branch runs the CI job and the results are written back as cards in the Pull Request thread on the GitHub Project; saving to the server runs the (container,command) Actions with that revision of the git repo.

Somewhat-equivalent GitOps CI Continuous Integration workflows (without Bazel or Blaze or gtest or gn, or GitHub Enterprise or GitHub Free due to the kids' intererests) that might be supported at least in analogue by Education and Chromebooks: k8s with podman-desktop in a VM, Gitea Actions (nektos/act; like Github Actions), devpod

devpod: https://github.com/loft-sh/devpod :

> Codespaces but open-source, client-only and unopinionated: Works with any IDE and lets you use any cloud, kubernetes or just localhost docker. (with devcontainer.json, like Github Codespaces)

devcontainer.json is supported by a number of tools; e.g. VScode, IntelliJ,: https://containers.dev/supporting

repo2docker has buildpacks (like Heroku and Google AppEngine).

repo2docker buildpacks should probably work with devcontainer.json too?

repo2docker docs > Usage > "REES: Reproducible Execution Environment" describes what all repo2docker will build a container from: https://repo2docker.readthedocs.io/en/latest/usage.html

jupyterhub/repo2docker builds a Dockerfile (Containerfile) from git repo (or a Figshare/Zenodo DOI) that minimally has at least an /environment.yml and /example.py (and probably also at least a /README.md to start with), and installs a current, updated version of jupyter notebook along with whatever's in e.g. /environment.yml per the REES spec. [1][2][3]

[1] repo2docker/buildpacks/base.py: https://github.com/jupyterhub/repo2docker/blob/main/repo2doc...

[2] "Make base_image configurable" https://github.com/jupyterhub/repo2docker/commit/20b08152578...

[3] repo2docker/buildpacks/conda/environment.py-3.11.yml:

Also see https://devpod.sh/ which has had quite a lot of exposure on HN recently.

For these reasons, I believe most developer environments should prioritize developer experience over fidelity. Tools like Containerized development environments and cloud emulators can strike the right balance and there’s no surprise that we see increased activity around devcontainers, and similar solutions.

Have you considered devcontainers?

Its use results in carrying entire development environments with you, while not cluttering your host OS.

Using DevPod (https://devpod.sh/) ypu are not locked into Visual Studio or Visual Studio Code, but you can use whatever tool you want.

IMO this kind of setup will provide a much better DX than running a bunch of VMs eating away the resources of your laptop.