There is a tendency to create services that where monolithic maintenance is best, or using javascript and python, and then overwhelming them with a complex deployment history. This situation leads to solutions like tying an entire web browser into an application, or using a container to limit a sprawling dependency tree of cryptic meat.
My little development distribution for windows, w64devkit, is my own few ways to counter this trend in the place where it affects me the most. Following in the footsteps of projects like handmade hero and shaping a video game from scratch, this is my guide to serious software development with the work of my development kit. This is an overview of the hardware and development workflow, and i've tried not to assume that the reader knows too much. Being more of a guide than a manual, it is by itself incomplete, and i refer to substantial external resources to fill in the gaps. The guide concludes with a little game, which i wrote entirely using the available design kit and serves as a demonstration of what things are not only possible, but really achievable.
Game repository: https: //github. Com/skeeto/asteroids-demo source guide: general information about asteroids
Initial setup
Of course you can't use the development kit when you don't have it either. Go to the releases section and download the latest version. This will make a zip video called w64devkit-x.Y.Z.Zip, where x.Y.Z is the version.
Before using the development kit, you need to unzip it. Windows has built-in support for .Zip files, so the patient can either right-click to access "extract all..." Or access that as a folder and then drag the w64devkit directory somewhere outside the .Zip file . It doesn't care where the building material is unzipped (aka "portable"), so put it where it's cool: on the desktop, in the user profile price list on a flash drive, etc. You can move it later if change your mind. Because you never use it actively. If you find that you no longer need it, delete it.
Entering the development environment
The w64devkit.Exe file is located in the unzipped w64devkit directory. This is a particularly optimal way to enter the development environment without having to change the system configuration. Windows puts the suite's programs in the path environment variable and then starts the bourne shell, the standard unix shell. Apart from the graphical editor, it is the central interface for software development. Gradually you can even extend this environment with your own tools.
If you need an extra "terminal" window, run w64devkit.Exe again. If you use it regularly you have the ability to provide a shortcut and instantly pin it to the taskbar.
Be it on windows or unix-like systems, when you type a command into the shell system it applies the variable environment path to determine the actual software to run this command. In fact, the path variable is a concatenation of several directories, and the shell searches these directories for a sequence. On unix-like systems, path elements are separated by colons. However, windows uses a colon to separate drive letters, so its path elements are separated by semicolons.
For more advanced users: instead of using w64devkit.Exe, you have the option to change the environment variables for your own mail or social network" . ” And manually add the w64devkit bin directory to a different path, making the tools publicly available anywhere on your system. If you go that route, you can start the bourne shell at any time with the sh -l command. (The -l option prompts a shell to access there.)
Also borrowed from unix life is the concept of the home directory, defined by the home environment variable. By default, such a step might be your user profile directory, usually c:/users/$user. Login shells always start in the home directory. This directory is often denoted by a tilde (~), and often programs automatically make the tilde the beginning of the home directory.
Shell basics
The shell is a command interpreter. It is named so because it was originally a shell around the os kernel - a user interface to the kernel. The graphical interface of your system is windows explorer or explorer.Exe - and by the way, it is also a kind of shell. This shell is mouse and graphics oriented. This is cool for most tasks, but a key-oriented shell is much easier for development tasks.It is more efficient, but more importantly, its functions can really be combined: complex operations and processes can be designed from simple and easy-to-understand tools. Accept it!
In a shell you have the ability to move between directories with cd, create directories with mkdir, delete files with rm, do a text search with regular expressions with grep, and etc. Run busybox to see a list of available standard commands. Unfortunately there are no man pages, however you can get basic information about using any command with busybox cmd --help.
Standard the windows command shell is cmd.Exe. Unfortunately, this wrapper is terrible and resides generally for legacy compatibility. The intended replacement is powershell for clients that regularly use the shell. However, powershell is completely broken, without exception does everything wrong and manages to be even worse than cmd.Exe. In addition, adherence to posix shell conventions significantly improves build portability, and knowledge of unix tools can be attributed almost to some other operating system.
The standard unix shell was the bourne, sh shell. The shells in use today are clones of the bourne shell with an extended set of features. The coolest interactive shells are bash and zsh. In linux dash (debian almquist shell) became in demand for non-interactive use (scripting). The shell included with w64devkit is a fork of the busybox shell of almquist (ash), download from the link - https://getof.net/ - closely related to dash. The almquist shell has almost no non-interactive features other than the standard bourne shell, and for this reason, in terms of scripting, it is available to study as a simple clone of the bourne shell. That's why i usually call it sh.
However, the almquist busybox shell has interactive features very similar to bash, and bash users should feel quite comfortable. It's not just tab completion, but a variety of emacs-like keyboard shortcuts:
Ctrl-r: search history for volumectrl-s: search forward historyctrl-p : previous command (up)ctrl-n: next command (down)ctrl-a: cursor to start of line (home)ctrl-e: cursor to end of line (end) alt- b: cursor back single wordalt-f: cursor forward single wordctrl-l: clear screenalt-d: delete word after cursorctrl-w : delete word before cursor ctrl-k: delete to the end of the linectrl-u: delete to the beginning of the linectrl-f: cursor forward (to the right) leading characterctrl-b: cursor back 1 character ( left)ctrl-d: delete the character under the cursor (delete)ctrl-h: delete the character before the cursor (backspace)
Pay close attention to the ctrl-r keyboard shortcut , which is the most important and powerful keyboard shortcut. Continued use is a good habit. Do not press the up arrow to view the command history.
Special note to you cygwin and msys2: the shell knows windows paths and does not represent the unix file system's virtual schema. This has important implications for scripting, both good and bad. The shell even supports the backslash as a directory separator, although you should of course prefer the forward slash.
Setting the shell
Login shells (-l) evaluate the contents of ~/.Profile on release. It's a great choice to tweak shell configuration, including, figure out environment variables, or determine aliases and health. That is, in the case where you want the tooltip to show the working directory in green, the athlete must set ps1 in your ~/.Profile:
If visitors find themselves using the same command sequences, or parameter set again, you can worry about what's going on to put those commands in the plot, and then set the specific script somewhere in your own path so you can run money and media as a command from scratch. First create a directory for bedding toys of your scripts, note in ~/bin:
In ~/.Profile add it to any path:
If you don't want to start a new shell to try it out, and then load the new configuration into your current shell:
Assume you keep confusing tar switches and just want to have an untar command that does the right thing. Create a file called untar or untar.Sh in ~/bin with the following content:
The untar something.Tar.Gz command will now extract the contents of the archive.
To to learn more about bourne shell scripting, a good reference is the posix shell command language specification. All functions set by this standard are open to your shell scripts.
Text editing
The development kit includes the powerful and popular vim text editor. It takes effort to learn, but it does make sense. It's packed full of features, but since you only need a small amount of them on a regular basis, it's not as problematic as it might seem. By using vim effectively, you will be writing and editing text much faster than before. This offers not only code, but also prose: readme, documentation, etc. Or even have trouble switching code between input styles, but thanks to now you'll know how vicious it really is, ignorance is bliss.)
Vim has its own guide for absolute beginners , which you have reason to access using the vimtutor command. It will launch in a console window and walk the customer through the basics for about a little over half an hour. Do not be afraid to return to the tutorial at any time, due to the fact that such a technique is all that is absolutely necessary to learn by heart.
When it comes time to use vim to write code, you can continue to write code through the terminal interface (vim) or you can start the graphical interface (gvim). The latter is recommended as it has some nice quality of life features, but, extra pounds is not strictly required. When releasing the gui, add an ampersand to the command (