# learn

**Repository Path**: mirrors_astaxie/learn

## Basic Information

- **Project Name**: learn
- **Description**: Learn.
- **Primary Language**: Unknown
- **License**: CC-BY-4.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-08-08
- **Last Updated**: 2026-05-30

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

My name is *Gyu-Ho Lee*, and I work at <a href="http://www.openmail.com" target="_blank">*OpenMail*</a>.

- **Email**: <a href="mailto:gyuho.cs@gmail.com" target="_blank">gyuho.cs@gmail.com</a>
- **Projects**: <a href="http://gyuho.github.io/" target="_blank">gyuho.github.io</a>
- **LinkedIn**: <a href="https://www.linkedin.com/in/gyuho" target="_blank">linkedin.com/in/gyuho</a>

I am an endless, active learner. I embrace challenges beyond my current abilities
to broaden my knowledge the most. I want to know a little about a lot,
and a lot about little: my favorites are C++ and Go.

**The best way to learn is to teach what you have learned to other people.**
I tried [YouTube channel](https://www.youtube.com/channel/UCWzSgIp_DYRQnEsJuH32Fww),
which was nice but *hard to maintain*. So I decided to write my own textbook
because it's more flexible and challenging. **I am still learning, and I may
say things out of ignorance.** Every post is *working in progress*,
non-committal on a timeline. The point is to review and improve over time.
This is a **_personal white-board_** where I *scribble* anything,
*organize* my code, learning experiences, and *display* my ability to
explain ideas from various fields.

I appreciate any kind of *feedback* or *suggestions*.
You can email <a href="mailto:gyuho.cs@gmail.com" target="_blank">gyuho.cs@gmail.com</a>, [`issues`](https://github.com/gyuho/learn/issues),
or [`pull request`](https://github.com/gyuho/learn/pulls).
I will respond within 24-hour.


<br>
​*Sincerely,*<br>
*Gyu-Ho Lee*

<br>
<br>
`LICENSE` can be found [here](./LICENSE.md).<br>
Please share with your friends and colleagues.<br>
<br>
<br>


<br><hr>
### Contents

- [Unix, linux](#unix-linux)
- [Assembly](#assembly)
- [C](#c)
- [C++](#c-1)
- [Go](#go)
- [Python](#python)
- [Concurrency, parallelism](#concurrency-parallelism)
- [Computer systems](#computer-systems)
- [Security systems](#security-systems)
- [Database systems](#database-systems)
- [Network systems](#network-systems)
- [Distributed systems](#distributed-systems)
- [Linguistics, natural language processing](#linguistics-natural-language-processing)
- [Mathematics, statistics](#mathematics-statistics)
- [Data structures and algorithms](#data-structures-and-algorithms)

[↑ top](#contents)
<br><br>



## Unix, linux

Unix is essential in software development.

> This is the Unix philosophy: Write programs 
> that do one thing and do it well.
>
> *Doug McIlroy*

- [*bash, vim*](https://github.com/gyuho/learn/tree/master/doc/bash_vim)

[↑ top](#contents)
<br><br>



## Assembly

> An assembly language (or assembler language) is a low-level programming
> language for a computer, or other programmable device, in which there is a
> very strong (generally one-to-one) correspondence between the language and
> the architecture's machine code instructions. Each assembly language is
> specific to a particular computer architecture, in contrast to most
> high-level programming languages, which are generally portable across
> multiple architectures, but require interpreting or compiling.
>
> [*Assembly language*](https://en.wikipedia.org/wiki/Assembly_language) *by
Wikipedia*

- [*Assembly: introduction*](https://github.com/gyuho/learn/tree/master/doc/assembly_introduction)
- [*Assembly: arithmetics, if*](https://github.com/gyuho/learn/tree/master/doc/assembly_arithmetics_if)

[↑ top](#contents)
<br><br>



## C

C is a small language. And it helps you better understand
how system works in low-level. It's still being used everywhere.
I only wish I had more time to learn more about C.

- [*C: introduction*](https://github.com/gyuho/learn/tree/master/doc/c_introduction)
- [*C: type, variable*](https://github.com/gyuho/learn/tree/master/doc/c_type_variable)
- [*C: logic, loop*](https://github.com/gyuho/learn/tree/master/doc/c_logic_loop)

[↑ top](#contents)
<br><br>



## C++

[**_Is learning C++ still worthwhile?_**](http://www.quora.com/Is-learning-C++-still-worthwhile)
Yes! I really want to learn more about C++:

> C++ is one of the most widely used programming languages
> in the world. Well-written C++ programs are fast and efficient.
> The language is more flexible than other languages because you
> can use it to create a wide range of apps—from fun and exciting
> games, to high-performance scientific software, to device drivers,
> embedded programs, and Windows client apps. For more than 20 years,
> C++ has been used to solve problems like these and many others.
>
> [*C/C++ Language and Standard Libraries*](https://msdn.microsoft.com/en-us/library/hh279654.aspx)
> *by Microsoft*

- [*C++: introduction*](https://github.com/gyuho/learn/tree/master/doc/cpp_introduction)
- [*C++: type, variable*](https://github.com/gyuho/learn/tree/master/doc/cpp_type_variable)
- [*C++: logic, loop*](https://github.com/gyuho/learn/tree/master/doc/cpp_logic_loop)
- [*C++: character, string, pointer, memory*](https://github.com/gyuho/learn/tree/master/doc/cpp_character_string_pointer_memory)
- [*C++: function*](https://github.com/gyuho/learn/tree/master/doc/cpp_function)
- [*C++: input, output*](https://github.com/gyuho/learn/tree/master/doc/cpp_input_output)
- [*C++: struct, union*](https://github.com/gyuho/learn/tree/master/doc/cpp_struct_union)
- [*C++: class, object*](https://github.com/gyuho/learn/tree/master/doc/cpp_class_object)
- [*C++: STL*](https://github.com/gyuho/learn/tree/master/doc/cpp_stl)

[↑ top](#contents)
<br><br>



## Go

I like [*Go*](https://golang.org/) for its simplicity: less design 
concerns to consider and less frameworks to learn. Plus I love its great communities.
Go is not perfect but really good at [*doing less, enabling more*](https://blog.golang.org/open-source).
It's a great introductory language between *Python* and *C++*.
**I want to know a lot about [C++](https://en.wikipedia.org/wiki/C%2B%2B)
and [Go](https://golang.org/) to build my foundation.**
This will help my transition to other languages or frameworks if needed.

- [*Go: introduction*](https://github.com/gyuho/learn/tree/master/doc/go_introduction)
- [*Go: type, variable*](https://github.com/gyuho/learn/tree/master/doc/go_type_variable)
- [*Go: logic, loop*](https://github.com/gyuho/learn/tree/master/doc/go_logic_loop)
- [*Go: character, string*](https://github.com/gyuho/learn/tree/master/doc/go_character_string)
- [*Go: strings, regex*](https://github.com/gyuho/learn/tree/master/doc/go_strings_regex)
- [*Go: sequence*](https://github.com/gyuho/learn/tree/master/doc/go_sequence)
- [*Go: map*](https://github.com/gyuho/learn/tree/master/doc/go_map)
- [**_Go: function, method, pointer, nil, map, slice_**](https://github.com/gyuho/learn/tree/master/doc/go_function_method_pointer_nil_map_slice)
- [*Go: struct*](https://github.com/gyuho/learn/tree/master/doc/go_struct)
- [**_Go: interface_**](https://github.com/gyuho/learn/tree/master/doc/go_interface)
- [*Go: argument, flag*](https://github.com/gyuho/learn/tree/master/doc/go_argument_flag)
- [**_Go: os, io_**](https://github.com/gyuho/learn/tree/master/doc/go_os_io)
- [*Go: sort, algorithm*](https://github.com/gyuho/learn/tree/master/doc/go_sort_algorithm)
- [*Go: random*](https://github.com/gyuho/learn/tree/master/doc/go_random)
- [*Go: time*](https://github.com/gyuho/learn/tree/master/doc/go_time)

[↑ top](#contents)
<br><br>



## Python

Python is probably fast enough for many of what we need to do today.
And it's relatively easy to learn and use, with rich ecosystems in
data science, web frameworks, scripting, and many others.

- [*Python: introduction*](https://github.com/gyuho/learn/tree/master/doc/python_introduction)
- [*Python: type, variable*](https://github.com/gyuho/learn/tree/master/doc/python_type_variable)
- [*Python: logic, loop*](https://github.com/gyuho/learn/tree/master/doc/python_logic_loop)
- [*Python: character, string*](https://github.com/gyuho/learn/tree/master/doc/python_character_string)
- [*Python: sequence*](https://github.com/gyuho/learn/tree/master/doc/python_sequence)
- [*Python: dictionary*](https://github.com/gyuho/learn/tree/master/doc/python_dictionary)
- [*Python: function*](https://github.com/gyuho/learn/tree/master/doc/python_function)
- [*Python: pointer, memory*](https://github.com/gyuho/learn/tree/master/doc/python_pointer_memory)
- [*Python: argument, flag*](https://github.com/gyuho/learn/tree/master/doc/python_argument_flag)
- [*Python: os, io*](https://github.com/gyuho/learn/tree/master/doc/python_os_io)
- [*Python: sort*](https://github.com/gyuho/learn/tree/master/doc/python_sort)
- [*Python: random*](https://github.com/gyuho/learn/tree/master/doc/python_random)
- [*Python: time*](https://github.com/gyuho/learn/tree/master/doc/python_time)

[↑ top](#contents)
<br><br>



## Concurrency, parallelism

*Parallelism* is about doing many things at the same time
instead of sequentially (one after another). *Concurrency* is about
composing those independently executing computations.

- [**_Go: concurrency_**](https://github.com/gyuho/learn/tree/master/doc/go_concurrency)
- [*Go: concurrent count*](https://github.com/gyuho/learn/tree/master/doc/go_concurrent_count)
- [*Go: concurrency, queue*](https://github.com/gyuho/learn/tree/master/doc/go_concurrency_queue)
- [*C++: concurrency*](https://github.com/gyuho/learn/tree/master/doc/cpp_concurrency)

[↑ top](#contents)
<br><br>



## Computer systems

It's very important to understand hardware and low-level programming.
I believe this will help a lot when you wonder why your high level program
is not working or not performing well. I will take as much time as 
I need―nothing like cramming 1,200 page computer systems book in 12 weeks.

- [*Overview of computer architecture*](https://github.com/gyuho/learn/tree/master/doc/overview_of_computer_architecture)
- [*Endianness*](https://github.com/gyuho/learn/tree/master/doc/endianness)
- [*Bitwise operation*](https://github.com/gyuho/learn/tree/master/doc/bitwise_operation)
- [*Segmentation fault, debug*](https://github.com/gyuho/learn/tree/master/doc/segmentation_fault_debug)

[↑ top](#contents)
<br><br>



## Security systems

[*MIT course*](http://css.csail.mit.edu/6.858/2014/schedule.html) explains that
*security achieves confidentiality, integrity, availability―policy*. And the goal is
to make sure there is no way for adversary within threat model to violate this policy.

- [*Go: archive, compress, encoding, decoding*](https://github.com/gyuho/learn/tree/master/doc/go_archive_compress_encoding_decoding)
- [*Go: hash, crypto*](https://github.com/gyuho/learn/tree/master/doc/go_hash_crypto)
- [*the matasano crypto challenges: set 1*](https://github.com/gyuho/learn/tree/master/doc/the_matasano_crypto_challenge_set_1)

[↑ top](#contents)
<br><br>



## Database systems

We are *generating* and *consuming* vast amounts of data in unprecendented
pace in human history. Database systems are the workhorses of our data 
analysis applications.

- [*mysql, postgresql, redshift*](https://github.com/gyuho/learn/tree/master/doc/mysql_postgresql_redshift)
- [*Go: sql*](https://github.com/gyuho/learn/tree/master/doc/go_sql)
- [*Go: key/value store, redis*](https://github.com/gyuho/learn/tree/master/doc/go_key_value_store_redis)
- [*Go: leveldb*](https://github.com/gyuho/learn/tree/master/doc/go_leveldb)
- [*Python: sql*](https://github.com/gyuho/learn/tree/master/doc/python_sql)
- [*Python: redis*](https://github.com/gyuho/learn/tree/master/doc/python_redis)
- [*Go: protobuf*](https://github.com/gyuho/learn/tree/master/doc/go_protobuf)

[↑ top](#contents)
<br><br>



## Network systems

I will show how to build web applications from scratch, with full-working code.

- [**_network, net, http_**](https://github.com/gyuho/learn/tree/master/doc/network_net_http)
- [**_ssh, scp_**](https://github.com/gyuho/learn/tree/master/doc/ssh_scp)
- [**_Go: web server with template, log, context_**](https://github.com/gyuho/learn/tree/master/doc/go_web_server_with_template_log_context)
- [**_Go: security, rate limit, graceful shutdown_**](https://github.com/gyuho/learn/tree/master/doc/go_security_rate_limit_graceful_shutdown)
- [**_Go: web application, deploy, container_**](https://github.com/gyuho/learn/tree/master/doc/go_web_application_deploy_container)

[↑ top](#contents)
<br><br>



## Distributed systems

You have one machine to run your program. What if that one machine fails? 
The whole system goes down. You want to have multiple, distributed machines
always available, so that even if one fails, others can keep running.
Distributed system provides **_consistency_**, **_availability_**,
*and* **_partition tolerance ([CAP theorem](https://en.wikipedia.org/wiki/CAP_theorem))_**.

- [**_etcd, priority queue, aws, gcp_**](https://github.com/gyuho/learn/tree/master/doc/etcd_priority_queue_aws_gcp)
- [**_etcd, raft algorithm_**](https://github.com/gyuho/learn/tree/master/doc/etcd_raft_algorithm)

[↑ top](#contents)
<br><br>



## Linguistics, natural language processing

I love linguistics, and its computational applications.

- [**_Go: string similarity_**](https://github.com/gyuho/learn/tree/master/doc/go_string_similarity)
- [*Go: segment*](https://github.com/gyuho/learn/tree/master/doc/go_segment)
- [*Go: spell check*](https://github.com/gyuho/learn/tree/master/doc/go_spell_check)

[↑ top](#contents)
<br><br>



## Mathematics, statistics

Most prominent solutions in Computer Science often come from mathematics. 
Arbitrary, unrelated things can fit together when you have mathematical
backgrounds. Statistics helps solve intractable problems through approximation 
algorithms, machine learning algorithms, etc.

- [*Go: bandit algorithms, adversarial bandits*](https://github.com/gyuho/learn/tree/master/doc/go_bandit_algorithms_adversarial_bandits)

[↑ top](#contents)
<br><br>



## Data structures and algorithms

- [*Computational complexity, NP*](https://github.com/gyuho/learn/tree/master/doc/computational_complexity_np)
- [*Recursion*](https://github.com/gyuho/learn/tree/master/doc/recursion)
- [*Linked list*](https://github.com/gyuho/learn/tree/master/doc/linked_list)
- [**_Binary search tree_**](https://github.com/gyuho/learn/tree/master/doc/binary_search_tree)
- [**_Go: heap, priority queue_**](https://github.com/gyuho/learn/tree/master/doc/go_heap_priority_queue)
- [**_Go: red black tree_**](https://github.com/gyuho/learn/tree/master/doc/go_red_black_tree)
- [**_Go: b-tree_**](https://github.com/gyuho/learn/tree/master/doc/go_b_tree)
- [**_Go: graph, interface_**](https://github.com/gyuho/learn/tree/master/doc/go_graph_interface)
- [**_Go: graph, traversal_**](https://github.com/gyuho/learn/tree/master/doc/go_graph_traversal)
- [**_Go: graph, shortest path_**](https://github.com/gyuho/learn/tree/master/doc/go_graph_shortest_path)
- [**_Go: graph, topological sort_**](https://github.com/gyuho/learn/tree/master/doc/go_graph_topological_sort)
- [**_Go: graph, minimum spanning tree_**](https://github.com/gyuho/learn/tree/master/doc/go_graph_minimum_spanning_tree)
- [**_Go: graph, strongly connected components_**](https://github.com/gyuho/learn/tree/master/doc/go_graph_strongly_connected_components)

[↑ top](#contents)
<br><br>