Programming

So my grandma is 94 years old. I started explaining her the basic computer science concepts that I use on a daily basis at work and she starting to take a very big interest in it and I for the point where she’s asked me to send her resources on how to get started and how to learn about binary numbers in the fundamentals on how computers work.

It was really cool how interested she was when I tried to explain to her how do you convert a binary number to a decimal number 🥹.

She said she never learned in school how to do x^y which was quite surprising to me.

Does anyone have any good advice for resources I could send her to help her start learning?

She has not text savvy at all, she can use email and her Mac computer with word docs. I definitely will be showing her how to use any technology. I’m hoping more for written articles or books explaing things so that anyone could understand . she’s a big reader.

Videos are not gonna work without caption, since she’s hard of hearing.

Any help would be appreciated. Thank you.

Is there somewhere that you can complain about bad stoplight programming? One of the lights on my way to work was recently reprogrammed and it completely skips my direction of travel for 3+ cycles even when there is a huge line at the light.

My grandfather recently bought me a since he used to engineer with them.
I've been programming software for years but my only PLC experience is programming a few Arduinos here and there for school projects. I want to learn how to put code into the Siemens PLC and get desired outputs like you can with Arduino's but honestly I have no idea how to. I tried downloading the Siemens TIA software but couldn't since it's confusing as hell to do, and I'm 99% sure I need to buy a license or something which I'm not sure if I want to yet.
Is there any free software I can download to be able to program the specific Siemens PLC i have or do I need to use the Siemens TIA?

Does Analog/RF incorporate writing code? In fact, I'm a master student and my focus is to be analog/RF design engineer and I started masters two months ago. Because I'm from a third world country, as soon as I got the offer for masters, I didn't think much and accept it right away. When I started, my advisor told me for now you have to deal with measurements of a chip they designed which requires programming. I'm into any kind of software and hates it too much. Summing up, does real analog/RF require the designer to use programming skills too much?

I've read a lot of post on this now but here's my take and phrasing of the question.

I just want to learn functional programing for personal development. I'm a pro java guy during the day so I'm not needing to get a job out of it, before anyone tells me to learn scala. I'm currently using sicp to learn and I like it so far but it is quite a long book so I'm starting to feel like there's a more productive path since I honestly don't care about the language it's the concepts etc I'm after. The main thing I don't want to do is learn some of the style in a language I already know like TS or Java as this is supposed to be fun and these languages make me think about work.

Any comments on your journey or what you think is good or worked etc would be great

Thanks

pytHON

HONorary mention to forTRAN

I know godots main languages are c# and gdscript but before jumping into a game engine, should i do something before hand like make something with like Python,lua,c# or something like that and what are some beginner projects for said language or godot in general? also what version of godot should i use or what ide is good to start with?

I dont really have much free time because of school and i feel unmotivated how do i overcome this aswell?

do i even need to study raw coding or can i hop into godot?

I see lots of people say on reddit that loads of the people working in programming jobs at their company don't even have a CompSci degree. They have archaeology or geography or any random degree instead. I am wondering what kind of jobs are these exactly, and in what kind of companies? I am learning programming on my own, and I am looking through indeed and none of the jobs seem particularly entry level, and none of them seem all too willing to employ anyone without a million different qualifications. I'm wondering if I'm looking in the wrong place? Am I searching the wrong keywords or going in with wrong expectations? I see people talking about hordes of people being employed working with computers without the relevant bachelors literally all the time and I've only now realise I have no idea what specific jobs these people are actually doing or how on earth they're getting into them. Thanks

Hey guys! I graduated last year and as stated on the title, im not good at programming and I can only do the basics. I understand the concept of programming naman and have basic background in web development and game development with unity.

Now, my dad is asking me to communicate to his friend's son because he owns a startup IT company. Im really worried right now because I suck ;>di talaga ako magaling and I might disappoint my dad baka mapahiya pa sya. ;> but at the same time I wanna try applying kasi gustong gusto ko din talaga makapasok sa Industry, its my dream to become a dev ;>

pleasee I badly need advice from those who are working in IT industry. Do i really need to be good in programming? May cases na ba na kahit hindi magaling magcode naging programmer and natuto katagalan? ;>

edit: Thank you so much po sa mga advices nyo!!

I’m considering a move over to industrial automation. I’ve been a fire alarm / suppression technician for 20+ years, am a licensed limited-energy electrician (Oregon), and have 15 years design and AutoCAD experience. From the posts I’ve seen and podcasts I’ve listened to, it seems like much of the design and programming goes to the guys with engineering degrees. Is that true? Is there room for electrician / technicians to program and design in industrial automation?

Pretty much the title, any views would be appreciated. Thanks

I am wondering, how would you solve the in your programming language? Here is how I solved it in the dialect of my programming language (AEC) which is targeting WebAssembly:

/*
 * My solution to the n-queens puzzle, one of the classical problems of the
 * structural programming. It asks in how many ways you can arrange n chess
 * queens on an n-times-n chessboard without breaking the rules that no two
 * chess queens can be in the same row, column or diagonal.
 */

// Import some functions we need to communicate with the outside world from
// JavaScript...
Function printString(PointerToCharacter str)
  Which Returns Nothing Is External;
Function clearScreen() Which Returns Nothing Is External;
Function shouldWePrintChessBoards() Which Returns Integer32 Is External;

// Declare the "Queen" structure and write relevant functions.
Structure Queen Consists Of
  Integer32 row, column;
EndStructure

Function areQueensInTheSameColumn(PointerToQueen first, PointerToQueen second)
  Which Returns Integer32 Does
    Return first->column = second->column;
EndFunction

Function areQueensInTheSameRow(PointerToQueen first, PointerToQueen second)
  Which Returns Integer32 Does
    Return first->row = second->row;
EndFunction

Function areQueensOnTheSameDiagonal(PointerToQueen first,
                                    PointerToQueen second)
  Which Returns Integer32 Does
    Return first->row + first->column = second->row + second->column or
           first->row - first->column = second->row - second->column;
EndFunction

Function areQueensAttackingEachOther(PointerToQueen first,
                                     PointerToQueen second)
  Which Returns Integer32 Does
    Return areQueensInTheSameRow(first, second) or
           areQueensInTheSameColumn(first, second) or
           areQueensOnTheSameDiagonal(first, second);
EndFunction

// Let's write a structure representing an array of queens...
Structure ChessBoard Consists Of
  Integer32 length;
  Queen queens[12]; // There are too many solutions for over 12 queens.
EndStructure

Function chessBoardContainsThatQueen(PointerToChessBoard chessBoard,
                                     PointerToQueen queen)
                                      Which Returns Integer32 Does
  Integer32 i := 0;
  While i < chessBoard->length Loop
    If chessBoard->queens[i].column = queen->column and
       chessBoard->queens[i].row    = queen->row    Then
      Return 1;
    EndIf
    i += 1;
  EndWhile
  Return 0;
EndFunction

// Now, let's forward-declare the functions we will write later.
// Putting them here would make the code less legible.
Function recursiveFunction(PointerToChessBoard chessBoard,
                           Integer32 n) Which Returns Integer32 Is Declared;

Function convertIntegerToString(PointerToCharacter str,
                                Integer32 n)
  Which Returns Nothing Is Declared;

Function strcat(PointerToCharacter dest,
                PointerToCharacter src) Which Returns Nothing Is Declared;

Function strlen(PointerToCharacter str) Which Returns Integer32 Is Declared;

// Let's write the function that JavaScript is supposed to call...
Function nQueensPuzzle(Integer32 n) Which Returns Integer32 Does
  clearScreen();
  If n < 1 or n > 12 Then
    printString("Please enter a number between 1 and 12!");
    Return -1;
  EndIf
  InstantiateStructure ChessBoard chessBoard;
  Character stringToBePrinted[64] := {0};
  PointerToCharacter stringToBePrinted := AddressOf(stringToBePrinted[0]);
  strcat(stringToBePrinted, "Solving the n-queens puzzle for ");
  convertIntegerToString(stringToBePrinted + strlen(stringToBePrinted),
                         n);
  strcat(stringToBePrinted,":\n");
  printString(stringToBePrinted);
  Integer32 result := recursiveFunction(AddressOf(chessBoard), n);
  stringToBePrinted[0] := 0;
  strcat(stringToBePrinted, "Found ");
  convertIntegerToString(stringToBePrinted + strlen(stringToBePrinted),
                         result);
  strcat(stringToBePrinted, " solutions!");
  printString(stringToBePrinted);
  Return result;
EndFunction

// I guess moving this code out of "recursiveFunction" makes the
// code more legible.
Function printAsASolution(PointerToChessBoard chessBoard)
  Which Returns Nothing Does
    Character stringToBePrinted[64] := {0};
    Character stringToBeAdded[8];
    Integer32 i := 0;
    While i < chessBoard->length Loop
      stringToBeAdded[0] := 'A' + chessBoard->queens[i].column;
      convertIntegerToString(AddressOf(stringToBeAdded[1]),
                             chessBoard->queens[i].row + 1);
      strcat(AddressOf(stringToBeAdded[0]), " ");
      strcat(AddressOf(stringToBePrinted[0]),
             AddressOf(stringToBeAdded[0]));
      i += 1;
    EndWhile
    strcat(AddressOf(stringToBePrinted[0]), "\n");
    printString(AddressOf(stringToBePrinted[0]));
    If shouldWePrintChessBoards() Then
        stringToBePrinted[0] := 0;
        PointerToCharacter stringToBePrinted := AddressOf(stringToBePrinted[0]);
        strcat(stringToBePrinted, "  +");
        i := 0;
        While i < chessBoard->length Loop
          strcat(stringToBePrinted, "-+");
          i += 1;
        EndWhile
        strcat(stringToBePrinted, "\n");
        printString(stringToBePrinted);
        i := chessBoard->length;
        While i > 0 Loop
          stringToBePrinted[0] := 0;
          // Align the row numbers to the right.
          If i < 10 Then
            strcat(stringToBePrinted, " ");
          EndIf
          convertIntegerToString(stringToBePrinted + strlen(stringToBePrinted), i);
          strcat(stringToBePrinted, "|");
          Integer32 j := 0;
          While j < chessBoard->length Loop
            InstantiateStructure Queen newQueen;
            newQueen.column :=     j;
            newQueen.row    := i - 1;
            strcat(stringToBePrinted,
                   chessBoardContainsThatQueen(chessBoard, AddressOf(newQueen))?
                   "Q|":
                   mod(i + j - 1, 2)?
                   " |": // White field.
                   "*|"  // Black field.
            );
            j += 1;
          EndWhile
          strcat(stringToBePrinted, "\n");
          printString(stringToBePrinted);
          stringToBePrinted[0] := 0;
          strcat(stringToBePrinted, "  +");
          j := 0;
          While j < chessBoard->length Loop
            strcat(stringToBePrinted, "-+");
            j += 1;
          EndWhile
          strcat(stringToBePrinted, "\n");
          printString(stringToBePrinted);
          i -= 1;
        EndWhile
        stringToBePrinted[0] := 0;
        PointerToCharacter stringToBeAdded := AddressOf(stringToBeAdded[0]);
        stringToBeAdded[2] := 0;
        stringToBeAdded[0] := ' ';
        strcat(stringToBePrinted, "  ");
        i := 0;
        While i < chessBoard->length Loop
          stringToBeAdded[1] := 'A' + i;
          strcat(stringToBePrinted, stringToBeAdded);
          i += 1;
        EndWhile
        strcat(stringToBePrinted, "\n");
        printString(stringToBePrinted);
    EndIf
EndFunction

// Now, let's implement the brute-force algorithm.
Function recursiveFunction(PointerToChessBoard chessBoard,
                           Integer32 n) Which Returns Integer32 Does
  // First, do some sanity checks useful for debugging...
  If chessBoard->length > n Then
    printString("Bug: Chessboard length too large!");
    Return 0;
  EndIf
  Integer32 i := 0, j := 0;
  While i < chessBoard->length Loop
    If chessBoard->queens[i].column < 0 or
       chessBoard->queens[i].row    < 0 or
       chessBoard->queens[i].column > n or
       chessBoard->queens[i].row    > n Then
      printString("Bug: Corrupt chessboard!");
      Return 0;
    EndIf
    i += 1;
  EndWhile
  // Check if there is a contradiction (queens attacking
  // each other) in what we have thus far...
  i := j := 0;
  While i < chessBoard->length Loop
    j := i + 1;
    While j < chessBoard->length Loop
      If not(i = j) and areQueensAttackingEachOther(
                          AddressOf(chessBoard->queens[i]),
                          AddressOf(chessBoard->queens[j])
                        ) Then
        Return 0;
      EndIf
      j += 1;
    EndWhile
    i += 1;
  EndWhile
  // Check if this is a solution...
  If chessBoard->length = n Then
    printAsASolution(chessBoard);
    Return 1;
  EndIf
  // If this is not a complete solution, but there are no contradictions
  // in it, branch the recursion into searching for complete solutions
  // based on this one.
  Integer32 result := 0;
  i := 0;
  While i<n Loop
    InstantiateStructure ChessBoard newChessBoard := ValueAt(chessBoard);
    newChessBoard.length += 1;
    newChessBoard.queens[chessBoard->length].column := chessBoard->length;
    newChessBoard.queens[chessBoard->length].row := i;
    result += recursiveFunction(AddressOf(newChessBoard), n);
    i += 1;
  EndWhile
  Return result;
EndFunction

// Now go the helper functions related to string manipulation,
// copied from the Dragon Curve program. They are named the same
// as the corresponding functions in the standard C library.
Function strlen(PointerToCharacter str) Which Returns Integer32 Does
     Integer32 length := 0;
     While ValueAt(str + length) Loop
         length := length + 1;
     EndWhile
     Return length;
EndFunction

Function strcpy(PointerToCharacter dest,
                PointerToCharacter src) Which Returns Nothing Does
    While ValueAt(src) Loop
        ValueAt(dest) := ValueAt(src);
        dest          :=     dest + 1;
        src           :=      src + 1;
     EndWhile
    ValueAt(dest) := 0;
EndFunction

Function strcat(PointerToCharacter dest,
                PointerToCharacter src) Which Returns Nothing Does
    strcpy(dest + strlen(dest), src);
EndFunction

Function reverseString(PointerToCharacter string) Which Returns Nothing Does
    PointerToCharacter pointerToLastCharacter := string + strlen(string) - 1;
    While pointerToLastCharacter - string > 0 Loop
        Character tmp                   := ValueAt(string);
        ValueAt(string)                 := ValueAt(pointerToLastCharacter);
        ValueAt(pointerToLastCharacter) := tmp;
        string                          := string + 1;
        pointerToLastCharacter          := pointerToLastCharacter - 1;
    EndWhile
EndFunction

Function convertIntegerToString(PointerToCharacter string,
                                Integer32 number)
    Which Returns Nothing Does
    Integer32 isNumberNegative := 0;
    If number < 0 Then
        number           := -number;
        isNumberNegative :=       1;
    EndIf
    Integer32 i := 0;
    While number > 9 Loop
        ValueAt(string + i) := '0' + mod(number, 10);
        number              :=           number / 10;
        i                   :=                 i + 1;
    EndWhile
    ValueAt(string + i) := '0' + number;
    i                   :=        i + 1;
    If isNumberNegative Then
        ValueAt(string + i) :=   '-';
        i                   := i + 1;
    EndIf
    ValueAt(string + i) := 0;
    reverseString(string);
EndFunction

You can see it .

And here is how I solved it in the dialect of my programming language which is targetting x86:

;A very advanced example: Solving the n-Queens Puzzle.
; https://flatassembler.github.io/nQueensPuzzle.html
AsmStart
    macro pushIntegerToTheSystemStack x
    {
        sub esp,4
        fld dword [x]
        fistp dword [esp]
    }
    macro pushPointerToTheSystemStack x
    {
        sub esp,4
        lea ebx,[x]
        mov [esp],ebx
    }
    macro pushStringToTheSystemStack x
    {
        sub esp,4
        mov dword [esp],x
    }
    format PE console
    entry start

    include 'win32a.inc'

    section '.text' code executable
    start:
AsmEnd
enterTheNumberString <= "Enter the number of queens.", 10, 0
floatSign <= "%f", 0
AsmStart
	pushPointerToTheSystemStack enterTheNumberString
	call [printf]
	add esp, 4 ;Cleaning up the system stack. When writing in assembly, there is no compiler to do that for you.
	pushPointerToTheSystemStack n
	pushPointerToTheSystemStack floatSign
	call [scanf]
	add esp, 8
AsmEnd
topOfMyStack := 1
numberOfSolutions := 0
myStack[topOfMyStack * (n + 1)] := 0
While topOfMyStack > 0
	howManyQueensAreOnTheBoard := myStack[topOfMyStack * (n + 1)]
	i := 0
	While i < howManyQueensAreOnTheBoard
		queens[i] := myStack[topOfMyStack * (n + 1) + i + 1]
		i := i + 1
	EndWhile
	topOfMyStack := topOfMyStack - 1
	If howManyQueensAreOnTheBoard = n
		numberOfSolutions := numberOfSolutions + 1
		i := 0
		While i < n
			integerSignFollowedBySpace <= "%d ", 0
			'A' + i ;The compiler will store this into the variable "result"
			AsmStart
				pushIntegerToTheSystemStack result
				call [putchar]
				add esp, 4
			AsmEnd
			queens[i] + 1
			AsmStart
				pushIntegerToTheSystemStack result
				pushPointerToTheSystemStack integerSignFollowedBySpace
				call [printf]
				add esp, 8
			AsmEnd
			i := i + 1
		EndWhile
		AsmStart
			pushPointerToTheSystemStack newLineString
			call [printf]
			add esp, 4
		AsmEnd
		twoSpacesAndPlus <= "  +",0
		AsmStart
			pushPointerToTheSystemStack twoSpacesAndPlus
			call [printf]
			add esp, 4
		AsmEnd
		column := 0
		While column < n
			minusFollowedByPlus <= "-+", 0
			AsmStart
				pushPointerToTheSystemStack minusFollowedByPlus
				call [printf]
				add esp, 4
			AsmEnd
			column := column + 1
		EndWhile
		AsmStart
			pushPointerToTheSystemStack newLineString
			call [printf]
			add esp, 4
		AsmEnd
		row := n - 1
		While row > 0 | row = 0
			integerSignPrecededBySpace <= " %d",0
			integerSign <= "%d",0
			If row + 1 < 10
				row + 1
				AsmStart
					pushIntegerToTheSystemStack result
					pushPointerToTheSystemStack integerSignPrecededBySpace
					call [printf]
					add esp, 8
				AsmEnd
			Else
				row + 1
				AsmStart
					pushIntegerToTheSystemStack result
					pushPointerToTheSystemStack integerSign
					call [printf]
					add esp, 8
				AsmEnd
			EndIf
			'|'
			AsmStart
				pushIntegerToTheSystemStack result
				call [putchar]
				add esp,4
			AsmEnd
			column := 0
			While column < n
				(queens[column] = row) ? 'Q' : (mod(row + column, 2) = 1) ? ' ' : '*'
				AsmStart
					pushIntegerToTheSystemStack result
					call [putchar]
					add esp, 4
				AsmEnd
				'|'
				AsmStart
					pushIntegerToTheSystemStack result
					call [putchar]
					add esp,4
				AsmEnd
				column := column + 1
			EndWhile
			AsmStart
				pushPointerToTheSystemStack newLineString
				call [printf]
				add esp, 4
			AsmEnd
			row := row - 1
			column := 0
			AsmStart
				pushPointerToTheSystemStack twoSpacesAndPlus
				call [printf]
				add esp, 4
			AsmEnd
			While column < n
				AsmStart
					pushPointerToTheSystemStack minusFollowedByPlus
					call [printf]
					add esp, 4
				AsmEnd
				column := column + 1
			EndWhile
			AsmStart
				pushPointerToTheSystemStack newLineString
				call [printf]
				add esp, 4
			AsmEnd
		EndWhile
		threeSpaces <= "   ", 0
		AsmStart
			pushPointerToTheSystemStack threeSpaces
			call [printf]
			add esp, 4
		AsmEnd
		column := 0
		While column < n
			'A' + column
			AsmStart
				pushIntegerToTheSystemStack result
				call [putchar]
				add esp, 4
			AsmEnd
			' '
			AsmStart
				pushIntegerToTheSystemStack result
				call [putchar]
				add esp, 4	
			AsmEnd
			column := column + 1
		EndWhile
		AsmStart
			pushPointerToTheSystemStack newLineString
			call [printf]
			add esp, 4
		AsmEnd
	Else
		rowOfTheQueenWeAreAboutToAdd := n - 1
		columnOfTheQueenWeAreAboutToAdd := howManyQueensAreOnTheBoard
		While rowOfTheQueenWeAreAboutToAdd > 0 | rowOfTheQueenWeAreAboutToAdd = 0
			isThereAQueenInTheSameRow := 0
			i := 0
			While i < howManyQueensAreOnTheBoard
				If queens[i] = rowOfTheQueenWeAreAboutToAdd
					isThereAQueenInTheSameRow := 1
				EndIf
				i := i + 1
			EndWhile
			isThereAQueenOnTheSameGlavnaDijagonala := 0 ;Sorry, I don't know how to say "glavna dijagonala" and "sporedna dijagonala" in English, and I am not wasting my time looking that up.
			i := 0
			While i < howManyQueensAreOnTheBoard
				If queens[i] + i = rowOfTheQueenWeAreAboutToAdd + columnOfTheQueenWeAreAboutToAdd
					isThereAQueenOnTheSameGlavnaDijagonala := 1
				EndIf
				i := i + 1
			EndWhile
			isThereAQueenOnTheSameSporednaDijagonala := 0
			i := 0
			While i < howManyQueensAreOnTheBoard
				If queens[i] - i = rowOfTheQueenWeAreAboutToAdd - columnOfTheQueenWeAreAboutToAdd
					isThereAQueenOnTheSameSporednaDijagonala := 1
				EndIf
				i := i + 1
			EndWhile
			isThereAQueenOnTheSameDiagonal := isThereAQueenOnTheSameGlavnaDijagonala = 1 | isThereAQueenOnTheSameSporednaDijagonala = 1
			If not(isThereAQueenInTheSameRow = 1) & not(isThereAQueenOnTheSameDiagonal = 1)
				topOfMyStack := topOfMyStack + 1
				myStack[topOfMyStack * (n + 1)] := howManyQueensAreOnTheBoard + 1
				i := 0
				While i < howManyQueensAreOnTheBoard
					myStack[topOfMyStack * (n + 1) + i + 1] := queens[i]
					i := i + 1
				EndWhile
				myStack[topOfMyStack * (n + 1) + howManyQueensAreOnTheBoard + 1] := rowOfTheQueenWeAreAboutToAdd
			EndIf
			rowOfTheQueenWeAreAboutToAdd := rowOfTheQueenWeAreAboutToAdd - 1
		EndWhile
	EndIf
EndWhile
foundSolutionsString <= "Found %d solutions!", 10, 0
AsmStart
    pushIntegerToTheSystemStack numberOfSolutions
    pushPointerToTheSystemStack foundSolutionsString
    call [printf]
    add esp, 8
    invoke system, _pause
    invoke exit, 0

    _pause db "PAUSE",0
    newLineString db 10,0

    section '.rdata' readable writable
	result dd ?
	n dd ?
	myStack dd 1024 dup(?)
	queens dd 16 dup(?)
	topOfMyStack dd ?
	i dd ?
	numberOfSolutions dd ?
	howManyQueensAreOnTheBoard dd ?
	rowOfTheQueenWeAreAboutToAdd dd ?
	columnOfTheQueenWeAreAboutToAdd dd ?
	isThereAQueenInTheSameRow dd ?
	isThereAQueenOnTheSameGlavnaDijagonala dd ?
	isThereAQueenOnTheSameSporednaDijagonala dd ?
	isThereAQueenOnTheSameDiagonal dd ?
	row dd ?
	column dd ?

    section '.idata' data readable import
        library msvcrt,'msvcrt.dll' ;Microsoft Visual C Runtime Library (comes with Windows 98 and newer).
            import msvcrt,printf,'printf',system,'system',exit,'exit',scanf,'scanf',putchar,'putchar'
AsmEnd

You can download the executable , it is called nQueensPuzzle.exe.

I started with Java as my first Language but I am confused as to when should I stop learning Java and start learning other things like DSA and Web Development.

No matter how much time I spend I'll never know a language fully so when should I stop.

As a newbie in programming that’s struggling to even install the right files, I’m curious to know what coding looks like after one has a more advanced knowledge repository.

I’ve heard that coding can be used to “solve problems,” but I don’t know what those problems are concretely. What does it mean to “solve problems” in coding? I’ve also heard of games like Codewars, and I’m curious to know what this actually looks and feels like.

I can only assume that coding has its own unique way of thinking, just like any other discipline. How do coders think? Or what kind of thinking does coding promote?

I know that people can create apps and programs, but is there something else that a coder can do as a hobby? I want to know what I can look forward to as I continue my coding journey.

Thank you :)

I about using outline-mode for elisp about 5 years ago and I've gone a bit potty since then on folding most everything I work with - to the extent that I've even dropped most org-mode usage to outline-mode as I never really used the funky stuff (like agenda, todo etc).

The motivation is that it makes viewing, organising and editing these files so much easier without the need to maintain +BEGIN/END SRC blocks and the tangling that comes with using org mode.

I've also implemented the imenu index stuff so that I can have an alphabetic index to my headings.

So far, I've converted elisp mode, org mode, sway, i3wm and waybar configurations to be folding with outline mode. The dotfiles are in .

;; *** outline-minor-mode
;; This makes outline-minor-mode operate a bit more like org-mode
;; <tab> & S-<tab>. If text-folding is all you need then outline is
;; 1593 LOC vs 127834 LOC for org (excl blanks, comments)

(with-eval-after-load "outline"
  (define-key outline-minor-mode-map (kbd "C-c C-c")
              (define-key outline-minor-mode-map [backtab] 'outline-cycle-buffer)
              ;; this enables C-c C-c to be used instead of the very awkward C-c C-@ prefix:
              (lookup-key outline-minor-mode-map (kbd "C-c @"))))

(add-hook 'outline-minor-mode-hook
          (lambda ()
            (define-key outline-minor-mode-map (kbd "C-c C-n") 'outline-next-visible-heading)
            (define-key outline-minor-mode-map (kbd "C-c C-p") 'outline-previous-visible-heading)
            (define-key outline-minor-mode-map (kbd "C-c C-f") 'outline-forward-same-level)
            (define-key outline-minor-mode-map (kbd "C-c C-b") 'outline-backward-same-level)
            (define-key outline-minor-mode-map (kbd "C-c C-u") 'outline-up-heading)
            (define-key outline-minor-mode-map (kbd "C-c C-a") 'outline-show-all)
            (define-key outline-minor-mode-map (kbd "C-c C-c C-a") 'outline-show-all)
            (define-key outline-minor-mode-map (kbd "<f1>") 'outline-toggle-children)

            (set-face-attribute 'outline-1 nil :height 120)
            (set-face-attribute 'outline-2 nil :height 115)
            (set-face-attribute 'outline-3 nil :height 110)
            (set-face-attribute 'outline-4 nil :height 105)
            
            (setq-local outline-minor-mode-use-buttons 'in-margins)
            (setq-local outline-minor-mode-highlight 'append)
            (setq-local outline-minor-mode-cycle t)))
(add-hook 'next-error-hook #'(lambda()
                               (if (member 'outline-mode (current-modes))
                                   (outline-show-all)))

Pictures tell a thousand words so ...

elisp for my config.el

;; Local Variables:
;; mode: elisp
;; outline-minor-mode-highlight: append
;; outline-regexp: ";;\s[*]+\s"
;; eval: (outline-minor-mode 1)
;; outline-level: (lambda() (- (outline-level) 4))
;; eval: (outline-hide-sublevels 1)
;; imenu-auto-rescan: nil
;; imenu-sort-function: imenu--sort-by-name
;; imenu-case-fold-search: t
;; imenu-generic-expression: (("headings" "^;; \\* \\(.*\\)$" 1) ("defun" "^([[:space:]]*defun[[:space:]]+\\([[:word:]-/]+\\).*$" 1) ("use-package" "^([[:space:]]*use-package[[:space:]]+\\([[:word:]-]+\\).*$" 1))
;; eval: (imenu-add-menubar-index)
;; End:

org

Local Variables:
truncate-lines: t
mode: text
eval: (add-hook (make-local-variable 'after-save-hook) 'bh/ensure-in-vc-or-check-in t)
outline-regexp: "[*\^L]+")
outline-minor-mode-highlight: append
eval: (outline-minor-mode 1)
eval: (outline-hide-sublevels 1)
eval: (auto-fill-mode -1)
imenu-generic-expression: ((nil "^\\* \\(.*\\)$" 1))
imenu-sort-function: imenu--sort-by-name
imenu-auto-rescan: nil
eval: (imenu-add-menubar-index)
End:

sway

# Local Variables:
# mode: text
# outline-regexp: "###+ "
# eval: (auto-fill-mode -1)
# outline-regexp: "###+ "
# outline-level: (lambda() (- (outline-level) 3))
# eval: (progn (outline-minor-mode 1)(outline-minor-mode 0)(outline-minor-mode 1))
# eval: (outline-hide-sublevels 1)
# imenu-generic-expression: ((nil "^### \\(.*\\)$" 1)("Global" "^#### _Global\\(#[0-9]+\\)*\\( \\|/\\)\\(.*\\)$" 3)("Output" "^#### Outpu_t\\(#[0-9]+\\)*\\( \\|/\\)\\(.*\\)$" 3)("Floater" "^#### _Floater\\(#[0-9]+\\)*\\( \\|/\\)\\(.*\\)$" 3)("Workspace" "^#### W_orkspace\\(#[0-9]+\\)*\\( \\|/\\)\\(.*\\)$" 3)("Window" "^#### _Window\\(#[0-9]+\\)*\\( \\|/\\)\\(.*\\)$" 3)("Run" "^#### _Run\\(#[0-9]+\\)*\\( \\|/\\)\\(.*\\)$" 3)))
# imenu-sort-function: imenu--sort-by-name
# imenu-auto-rescan: nil
# eval: (imenu-add-menubar-index)
# End:

waybar

// for emacs:
// Local Variables:
// mode: text
// outline-regexp: "    \""
// eval: (auto-fill-mode -1)
// eval: (outline-minor-mode 1)
// eval: (outline-show-only-headings)
// outline-level: (lambda() (- (outline-level) 4))
// imenu-generic-expression: ((nil "^    \"\\(.*\\)$" 1))
// imenu-sort-function: imenu--sort-by-name
// imenu-auto-rescan: nil
// eval: (imenu-add-menubar-index)
// End:      

Hi all!

I've made another Python cheat sheet tutorial. Yeah yeah, nothing new, I know. But here's the thing:

What My Project Does

The main idea was not just to write a wall of text telling about everything, but to make it interactive. So that everything would have its example code snippet, which you could change, run, and see how it worked. And not somewhere in a web version, but on your own computer, in your own environment.

Fortunately, Python has the perfect tool for this - the Jupyter Notebook. That's why all chapters are written as separate notebooks and there is an example for each point (well, almost).

Target Audience

I originally aimed at complete beginners and tried to go from simple to complex, but I think I overdid it at some point. So it might be just as suitable to refresh knowledge and fill in the gaps for anyone.

What else

It also has some useful information for Python-developer interview preparation and a link to the absolutely wonderful Tech Interview Handbook for Coding Interview preparation in case anyone missed it.

I would very welcome any constructive criticism, any advice, and of course contributions and GitHub stars :)

A little less, but still I will be glad to unreasonable hatred and comments that nobody needs it and that there are hundreds of similar projects on the Internet.

Check out the project on GitHub:

Can you answer a few questions for me?

How do you usually read textbooks? Do you know any good tutorials or can you give me some tips? I don't know how to read theoretical programming books, I end up reading them like novels.

What is your favorite competitive programming platform?

How did you learn English? (I have 100% difficulty with this part)