- [#techwarn]: Warning
Because of a substantial amount of danger posed to data security and integrity, please take the time to review this site's certain technology warning (and also the early warning prediction) before proceeding to apply any other information.
Even those who know how to count in hexadecimal (and binary) may benefit from learning about the super-fast converting between binary and hexadecimal. However, it makes sense to start by making sure there's an understanding of what these digits are.
A guide for counting in decimal, binary, and hexadecimal is provided. (The concept of “counting in decimal” is just provided for comparison, because this comparison allows for an easy way to quickly understand how the other numbering systems work.) See: How to count.
- [#digitnam], [#howincrm], [#incrdec], [#incrbin], [#decrbin], [#incrhex]
- (The related sections have been moved. If an older hyperlink went to this section, check the address bar to see which anchor was being referenced. Then, see the latest content, hop on over to the relvant section: [#digitnam]: Terminology note, [#howincrm]: How to increment, [#incrdec]: Counting up in decimal, [#incrbin]: Counting up in binary, [#decrbin]: Counting down in binary, [#incrhex]: Counting up and/or adding in hexadecimal.)
- [#cnvhexbn]: Super-fast converting between binary and hexadecimal
This section has also moved. See: Super-fast converting between binary and hexadecimal.
- Converting between decimal and binary/hexadecimal
Related information has been moved. See the “Numbers” section, underneath the section about Super-fast converting between binary and hexadecimal.
- [#powoftwo]: Powers of two
This section has moved. See: Powers of two.
- [#usrifbas]: User Interface Basics/Details
See: User Interface Basics/Details. Some topics may include:
- Command line usage
- Commands, arguments/parameters: making a directory, changing directories (absolute), relative directories, environmental variables, PATH, common interface (command line recall)
- Keyboard shortcuts in a GUI
Details may include: User interface details (such as how to use a command line, and effective use of keyboard shortcuts).
- [#netwkady]: Network Addresses
- Information has now been moved to: network addresses
- (For a similar topic, also see: device addresses.)
- [#netbasic]: Networking basics
- See: Networking basics
- Networking details
Understanding network routing basics may be a slightly more advanced topic. The “routing basics” guide in the section on network routing, and particularly the portion about routing for local subnets explains the purposes of things like a default gateway, and how a prefix length (using new terminology) or subnet mask (older terminology) gets used.
- [#mkpwlrdm]: Password selection/creation (making passwords looking random)
The supreme lack of security implemented by many individuals remains stunning. So, here is a quick guide for coming up with some passwords that may be better than some typical common passwords. (Obviously, those common passwords should be avoided when trying to secure something.)
Hopefully the use of weak passwords will diminish as people find easier ways than re-usable passwords to secure things. Details about such methods may include authorization keys and one-time credentials (which may be considered less basic topics).
- Using random (easily typable) characters
If a random character generator isn't happily available, then use this method: randomly decide whether or not to hold the shift key with one hand. With the other hand, let rather randomly drop onto the side or middle of the keyboard. Try to do this with different rows, including numbers.
This may be prone to generate text like “asdf”, where many letters are surrounded by other letters that are nearby on the keyboard. Also, this may reduce the likelihood of repeated letters.
To counter that first limitation, take the resulting text and copy a few random characters to a new location. Do that at least a few times, and the result should be a string of mumbo-jumbo. If the password isn't long enough, repeat the process.
This is a simple (although a bit slow) process that helps generate some relatively complex-style passwords for other people to use. (The reason this is favored for other people is because this doesn't require any explanation about patterns to try to memorize the password. For passwords that are going to be used by the person selecting/creating the password, it may be better to employ a pattern to create a password that is easier to memorize.)
- Using a pattern
Think that “BmspaCJ-Id'ciIngb” seems like a very difficult password to memorize? Perhaps so, except for people who are familiar with the song, “Take me out to the ball game”. Specifically, that example password is derived from the initials of the words “Buy me some peanuts and Cracker Jack. I don't care if I never get back!” This is a simple example of how a well-known phrase can turn into a complicated-looking password that is easy to memorize.
Of course, such a phrase might be a bit long, and challenging to type. Also, nobody who has read this text should use that precise password, because simply making an exact copy of a public example is a terrible way to select a set of credentials. However, minor variations to the above technique can be used to create some easy to memorize passwords. Further, passwords created with such methods may be much better than the simplest ones that many people try to use (hoping that simplicity will lead to easy memorization).
Think of some random words or phrases. For instance, think of several words from a song, or a movie, advertising slogan, famous quotation, etc. that has not been super popular during the most recent quarter of experienced life. (So a person who is fifteen years old should try to think of something from about four years ago, or earlier.) Pick something that has not been knowingly mentioned in the last week. (Meaning, it may have been mentioned by someone on the planet, but details (like who heard the phrase) may be less known. Another method for coming up with words may be to list the last names of influential people. (Don't just pick family members or schoolteachers: Even people growing up together may have a different list than other classmates and family members.) Using phrases from a small number of common sources (such as related historical figures, possibly including fictional figures) may also be a method to generate some memorable words.
Got a list of words that will never be forgotten? Good. Then proceed.
Then, randomly select a number that is less than five. (A less random method could involve adding the digits of a birthdate, adding some other uncommon number like the number of siblings born to a person's oldest aunt, and then dividing by four.) Use that number to take an appropriate letter from the first syllable. (For instance, if the number was two, take the second letter from the first syllable.) Then use some sort of pattern to determine which letter to take from the next syllable.
The beauty of this method is that it generates some rather random looking gibberish, although this gibberish is actually rather easily memorable (or re-creatable) by a person who knows the phrase and pattern(s) used. Even better: the pattern(s) may be re-used for other websites, so one person using a consistent pattern can create unique passwords fairly quickly without an attacker necessarily being able to recognize the pattern (to use it for other sites).
- Making code
Computers follow instructions. A list of instructions is called a “program” (frequently referred to as a “computer program”). The instructions can be challenging to read, particularly for people who have not received training in understanding instructions. Therefore, these instructions, as well as a computer program made up of these instructions, may also be known as “code”. The term “software” generally refers to a computer program, or multiple programs. (Other computerized information has, sometimes, been categorized as “software”, when the distinction being made was between software and hardware. However, now information is generally called “data” unless it meant to be instructions that a computer may follow.)
Further details are available in a guide in the coding section: making code.