ICO wiki - User contributions [en]

Htop, the successor of top

2016-05-08T17:07:03Z

Smets: /* Installing htop on Ubuntu and a quick guide */

__NOTOC__
[[File:htop.png|thumb|right|alt= Screenshot of htop in action|Screenshot of htop in action]]

<code>htop</code>, like <code>top</code> (table of processes), is a simple command on the command line designed for Linux, OS X, FreeBSD, OpenBSD. It is used to monitor the system and get an overview over processes happening inside the computer live. <code>htop</code> shows how much processing power and memory are being used, as well as other information about the running processes. The information gathered is ordered by CPU usage.

It was developed by Hisham Muhammad around May 2004 but the most stable version of it was released in early 2016. Both <code>top</code> and <code>htop</code> are written in C and both of them are used for the same purposes and act as a task manager, hence the question: why do we need two of the same kind?

<code>htop</code> is being constantly updated and tweaked by the developer to give you a better experience.

__TOC__

== Comparison between htop and top ==

The question stated above will find its answer here where we compare htop and top:

'''1.''' In <code>htop</code> you can scroll the list vertically and horizontally to see all processes and complete command lines.

'''2.''' In <code>top</code> you are subject to a delay for each unassigned key you press (especially annoying when multi-key escape sequences are triggered by accident).

'''3.''' <code>htop</code> starts faster (<code>top</code> seems to collect data for a while before displaying anything).

'''4.''' In <code>htop</code> you don't need to type the process number to kill a process, in <code>top</code> you do.

'''5.''' In <code>htop</code> you don't need to type the process number or the priority value to renice a process, in <code>top</code> you do.

'''6.''' <code>htop</code> supports mouse operation, <code>top</code> doesn't.

'''7.''' <code>top</code> is older, hence, more used and tested.

=== Conclusion ===

<code>htop</code> is just like <code>top</code>, but greatly improved visually and performance wise, including interactivity and the support of mouse operations.

== Installing htop on Ubuntu and a quick guide ==
'''1.''' You can either grab the source code from the htop website (See Also section) or you can do it the easy way and install it with apt-get

<code>sudo apt-get install htop</code>

And that's the only step you need to take! Now you can enjoy a greatly improved graph.

'''1.''' Type <code>htop</code> on your command line to start it up.

'''2.''' Move up and down with your arrow keys to select a process and with htop you have the ability to kill your processes with the F9 key.

'''3.''' You can even change the priority of the process by using the F7 and F8 keys.

'''4.''' You can also use the F6 key to change the default sort column.

== See Also ==

http://hisham.hm/htop/

== References ==

https://en.wikipedia.org/wiki/Htop

http://hisham.hm/htop/index.php?page=comparison

https://en.wikipedia.org/wiki/Top_(software)

Article created by Sander Mets, C11, EIK.

[[Category:Operatsioonisüsteemide administreerimine ja sidumine]]

Htop, the successor of top

2016-05-08T16:22:28Z

Smets:

__NOTOC__
[[File:htop.png|thumb|right|alt= Screenshot of htop in action|Screenshot of htop in action]]

<code>htop</code>, like <code>top</code> (table of processes), is a simple command on the command line designed for Linux, OS X, FreeBSD, OpenBSD. It is used to monitor the system and get an overview over processes happening inside the computer live. <code>htop</code> shows how much processing power and memory are being used, as well as other information about the running processes. The information gathered is ordered by CPU usage.

It was developed by Hisham Muhammad around May 2004 but the most stable version of it was released in early 2016. Both <code>top</code> and <code>htop</code> are written in C and both of them are used for the same purposes and act as a task manager, hence the question: why do we need two of the same kind?

<code>htop</code> is being constantly updated and tweaked by the developer to give you a better experience.

__TOC__

== Comparison between htop and top ==

The question stated above will find its answer here where we compare htop and top:

'''1.''' In <code>htop</code> you can scroll the list vertically and horizontally to see all processes and complete command lines.

'''2.''' In <code>top</code> you are subject to a delay for each unassigned key you press (especially annoying when multi-key escape sequences are triggered by accident).

'''3.''' <code>htop</code> starts faster (<code>top</code> seems to collect data for a while before displaying anything).

'''4.''' In <code>htop</code> you don't need to type the process number to kill a process, in <code>top</code> you do.

'''5.''' In <code>htop</code> you don't need to type the process number or the priority value to renice a process, in <code>top</code> you do.

'''6.''' <code>htop</code> supports mouse operation, <code>top</code> doesn't.

'''7.''' <code>top</code> is older, hence, more used and tested.

=== Conclusion ===

<code>htop</code> is just like <code>top</code>, but greatly improved visually and performance wise, including interactivity and the support of mouse operations.

== Installing htop on Ubuntu and a quick guide ==
'''1.''' You can either grab the source code from the htop website or you can do it the easy way and install it with apt-get

<code>sudo apt-get install htop</code>

And that's the only step you need to take! Now you can enjoy a greatly improved graph.

'''1.''' Type <code>htop</code> on your command line to start it up.

'''2.''' Move up and down with your arrow keys to select a process and with htop you have the ability to kill your processes with the F9 key.

'''3.''' You can even change the priority of the process by using the F7 and F8 keys.

'''4.''' You can also use the F6 key to change the default sort column.

== See Also ==

http://hisham.hm/htop/

== References ==

https://en.wikipedia.org/wiki/Htop

http://hisham.hm/htop/index.php?page=comparison

https://en.wikipedia.org/wiki/Top_(software)

Article created by Sander Mets, C11, EIK.

[[Category:Operatsioonisüsteemide administreerimine ja sidumine]]

Htop, the successor of top

2016-05-08T15:29:44Z

Smets: Created page with "__NOTOC__ Screenshot of htop in action <code>htop</code>, like <code>top</code> (table of processes), is a sim..."

__NOTOC__
[[File:htop.png|thumb|right|alt= Screenshot of htop in action|Screenshot of htop in action]]

<code>htop</code>, like <code>top</code> (table of processes), is a simple command on the command line designed for Linux, OS X, FreeBSD, OpenBSD. It is used to monitor the system and get an overview over processes happening inside the computer live. <code>htop</code> shows how much processing power and memory are being used, as well as other information about the running processes. The information gathered is ordered by CPU usage.

It was developed by Hisham Muhammad around May 2004 but the most stable version of it was released in early 2016. Both <code>top</code> and <code>htop</code> are written in C and both of them are used for the same purposes and act as a task manager, hence the question: why do we need two of the same kind?

<code>htop</code> is being constantly updated and tweaked by the developer to give you a better experience.

__TOC__

== Comparison between htop and top ==

The question stated above will find its answer here where we compare htop and top:

'''1.''' In <code>htop</code> you can scroll the list vertically and horizontally to see all processes and complete command lines.

'''2.''' In <code>top</code> you are subject to a delay for each unassigned key you press (especially annoying when multi-key escape sequences are triggered by accident).

'''3.''' <code>htop</code> starts faster (<code>top</code> seems to collect data for a while before displaying anything).

'''4.''' In <code>htop</code> you don't need to type the process number to kill a process, in <code>top</code> you do.

'''5.''' In <code>htop</code> you don't need to type the process number or the priority value to renice a process, in <code>top</code> you do.

'''6.''' <code>htop</code> supports mouse operation, <code>top</code> doesn't.

'''7.''' <code>top</code> is older, hence, more used and tested.

=== Conclusion ===

<code>htop</code> is just like <code>top</code>, but greatly improved visually and performance wise, including interactivity and the support of mouse operations.

== Installing htop on Ubuntu and a quick guide ==
'''1.''' You can either grab the source code from the htop website or you can do it the easy way and install it with apt-get

<code>sudo apt-get install htop</code>

And that's the only step you need to take! Now you can enjoy a greatly improved graph.

'''1.''' Type <code>htop</code> on your command line to start it up.

'''2.''' Move up and down with your arrow keys to select a process and with htop you have the ability to kill your processes with the F9 key.

'''3.''' You can even change the priority of the process by using the F7 and F8 keys.

'''4.''' You can also use the F6 key to change the default sort column.

== See Also ==

http://hisham.hm/htop/

== References ==

https://en.wikipedia.org/wiki/Htop

http://hisham.hm/htop/index.php?page=comparison

https://en.wikipedia.org/wiki/Top_(software)

File:Htop.png

2016-05-08T14:24:55Z

Smets: Smets uploaded a new version of File:Htop.png

Category:I600 Introduction to Computers and Informatics

2016-01-26T19:39:10Z

Smets: /* Grading */

In this course we'll give an introduction to variety of topics from hardware to software.
The course will follow roughly the same structure as [https://lagunita.stanford.edu/courses/Engineering/CS101/Summer2014/about Computer Science 101 at Stanford University] with more hands-on approach. This course substitutes Estonian courses I100 Sissejuhatus informaatikasse and [http://www.pld.ttu.ee/~teet/itarvutid.html I201 Arvutid].

Monday lectures will cover more theoretical stuff;
Thursday workshops are for getting started with new topics;
the homework assignments connect theoretical with practice and
Tuesday sessions are for follow up, asking/answering questions and presenting homework.
Attendance won't be tracked, the sessions are there if you need help.
Bring your laptops for Tuesday and Thursday sessions.

Course credits: 6 ECTS

Lecturer: Lauri Võsandi

E-mail: lauri [donut] vosandi [plus] i600 [ät] gmail [dotchka] com

=Grading=

Grade mapping:

* 0-50 points, fail
* 51-60 points, pass 1
* 61-70 points, satisfactory 2
* 71-80 points, average 3
* 81-90 points, good 4
* 91-100 points, very good 5

Grading is split between theory and practice

* Exam of 50 points, preparation in lectures and general discussion in workshops.
* Assignments, see instructions and points below.
* Extra points for improving quality of wiki articles, extracurricular work and also helping others, see points below.

Exam will be halfway between oral and written: You'll be given 30 minutes to prepare for several random questions and 15 minutes to discuss what you've answered.
If you don't have prior experience with the topics, it's highly recommended to take part of the sessions in order to pass the exam. You can use a calculator and this wiki page, don't rely on the access to terminal or other software tools. You can not access Internet or any remote computers.

Exam sections:

* Execution of ~10 processor instructions
* Bunch of randomly selected questions from this page
* Bunch of questions (how much RAM, how big disk, what wireless chipset) asked about a computer you'll be given
* Gain SSH access to a machine on the network, basic text file editing skills using nano

Retake times 27th of January:

* 12. jan 14:00 -
* 12. jan 14:30 -
* 12. jan 15:00 -
* 12. jan 15:30 - Sander Mets
* 13. jan 16:00 - Kristjan Saaremets
* 13. jan 16:30 -
* 13. jan 17:00 -
* 13. jan 17:30 - Indrek Taal

=Lecture: Computer hardware=

Jargon: CPU, RAM, ROM, HDD, SSD, PCI, PCI Express, USB 2.0, USB 3.0, VGA, HDMI, DVI, LCD, TFT, LED, OLED, AMOLED, CRT, PWM

[https://echo360.e-ope.ee/ess/echo/presentation/beef71c3-044c-43c9-a326-e1e62cbb5c9b Lecture recording #1]

[https://echo360.e-ope.ee/ess/echo/presentation/36786bbb-84b6-4604-be6f-c363bf22ce8d Lecture recording #2 starting 12:30]

[https://docs.google.com/presentation/d/1OzaqTBAUfMOzhG0HZeSJVSszCmFyn4ug35teYJWkyfM/edit?usp=sharing Lecture slides] Random access memory, permanent storage, buses, input devices, display technologies, networking

Potential exam questions:

* Different buses and their uses
* What are the differences between hard disk drive (HDD) and solid state drive (SSD)? [http://www.storagereview.com/ssd_vs_hdd]
* What is the purpose of Flash Translation Layer in terms of solid state drives?
* What are difference between volatile/non-volatile, RAM, ROM, EEPROM and where are they used?
* What is data retention?
* What are difference between asynchronous/synchronous, dynamic/static RAM and where are they used?
* What is [https://compsci2014.wikispaces.com/2.1.3+Explain+the+use+of+cache+memory cache]? What is cache coherence?
* What are differences between resistive and capacitive touchscreen? [http://www.alphr.com/realworld/357325/capacitive-or-resistive-whats-the-best-type-of-touchscreen]
* Explain how [http://www.bidouille.org/hack/mousecam computer mouse] works? [http://www.topdesignmag.com/mouse-history-in-photos/ History of computer mouse].
* Explain how [http://www.daskeyboard.com/blog/typing-through-time-the-history-of-the-keyboard/ computer keyboard] works? [http://computer.howstuffworks.com/keyboard.htm HowStuffworks article] [http://www.explainthatstuff.com/computerkeyboards.html Explain that Stuff article] [http://www.daskeyboard.com/blog/typing-through-time-the-history-of-the-keyboard/ Keyboard History]
* Explain how [https://en.wikipedia.org/wiki/Cathode_ray_tube cathode ray tube] (CRT) based screen technology works and name pros/cons. [https://www.youtube.com/watch?v=2czqYV3T_Kc]
* Explain how [https://en.wikipedia.org/wiki/Liquid-crystal_display liquid crystal displays] (LCD) work and name pros/cons. [https://www.youtube.com/watch?v=nCHgmCxGEzY]
* Name screen technologies making use of thin film transistor (TFT) technology? [https://en.wikipedia.org/wiki/Thin-film_transistor]
* Name uses for light polarization filters? [https://en.wikipedia.org/wiki/Polarizing_filter_%28photography%29] [https://en.wikipedia.org/wiki/Polarized_3D_system]
* What are the benefits of [https://en.wikipedia.org/wiki/Twisted_pair twisted pair cabling] and [https://en.wikipedia.org/wiki/Differential_signaling differential signalling]?
* [https://en.wikipedia.org/wiki/Active_matrix Active matrix] vs [https://en.wikipedia.org/wiki/Passive_matrix_addressing passive matrix] in display technology

Security section: [http://www.bunniestudios.com/blog/?p=3554 Hacking SD cards]

Assignments:
* [https://wiki.itcollege.ee/index.php/I600_Introduction_to_Computers_and_Informatics#Assignment:_Investigating_PC_hardware Investigating PC hardware]
* [https://wiki.itcollege.ee/index.php/I600_Introduction_to_Computers_and_Informatics#Assignment:_Investigating_embedded_hardware Investigating embedded hardware]

=Lecture: Storage abstractions=

In this lecture we'll talk about permanent storage abstractions: block device, disk, partition, file system, directory/folder, file, journaling, FAT32, NTFS, ext4, HFS+

[https://docs.google.com/presentation/d/1dJ-HMSR9nW8OuZtSTYf5dlFyPsZKGqxlKoEwIHi9h6k/ Lecture slides]

[https://echo360.e-ope.ee/ess/echo/presentation/36786bbb-84b6-4604-be6f-c363bf22ce8d Lecture recording] starts at 47:50.

* What is a [https://en.wikipedia.org/wiki/Block_%28data_storage%29 block device]?
* What is [https://en.wikipedia.org/wiki/Logical_block_addressing logical block addressing] and what are the benefits compared to older [https://en.wikipedia.org/wiki/Cylinder-head-sector cylinder-head-sector addressing] method in terms of harddisks?
* What is a [https://en.wikipedia.org/wiki/Disk_partitioning disk partition]?
* What is a [https://en.wikipedia.org/wiki/File_system file system]?
* What is [https://en.wikipedia.org/wiki/Journaling_file_system#Write_hazards journaling] in terms of filesystems and what are the benefits? Name some journaled filesystems in use nowadays.

=Lecture: Bootloaders, kernels=

In this lecture we'll discuss how a computer boots and how an operating system kernel is loaded.

[https://echo360.e-ope.ee/ess/echo/presentation/04eeebd1-c892-485a-9123-03abaa3ce3ca Lecture recording #1], first half we'll discuss about first assignment about investigating PC hardware, slides start at 43:40.

[https://echo360.e-ope.ee/ess/echo/presentation/26f1d40d-7830-4e5c-b783-e061c1e91cfc Lecture recording #2], first 15 minutes we'll discuss about second assignment about investigating embedded hardware, last slides about kernels are discussed from 16:00 up to 27:30. I forgot to switch video input for lecture recording so you'll have to browse slides from the link below :/

Lecture slides:
[https://docs.google.com/presentation/d/1ybYQEqCgN1KdVW1sLdwtfRogavgzzMQdUfTcAnxNAf4/ bootloaders],
[https://docs.google.com/presentation/d/1xDL27k3z_0I-IKzdjKkwhOhBrg0aOnM0w0u1zDwaEWY/ kernels].

Jargon: [https://en.wikipedia.org/wiki/BIOS BIOS] (basic input/output system), [https://en.wikipedia.org/wiki/Unified_Extensible_Firmware_Interface UEFI] (Unified Extensible Firmware Interface), bootloader, kernel, process, context switch, x86 real/protected mode, paged virtual memory, swap/pagefile, [https://en.wikipedia.org/wiki/User_space kernelspace/supervisor mode, userspace], [https://en.wikipedia.org/wiki/Protection_ring#Hypervisor_mode hypervisor mode] (ring -1), [https://en.wikipedia.org/wiki/System_Management_Mode#Problems system management mode] aka (ring -2).

Potential exam questions:

* What is the role of BIOS/UEFI in x86-based machines?
* Explain step by step how operating system is booted up, see slides for flowchart.
* Describe the functionality provided by general purpose operating system. See architecture of [https://en.wikipedia.org/wiki/Architecture_of_Windows_NT Windows NT], [http://www.elinux.org/Android_Architecture Android], [https://en.wikipedia.org/wiki/Architecture_of_OS_X OS X].
* What are the main differences between [https://en.wikipedia.org/wiki/Real_mode real mode] and [https://en.wikipedia.org/wiki/Protected_mode protected mode] of x86-based processor?
* What happens during context switch?
* What is the purpose of [https://en.wikipedia.org/wiki/Virtual_memory paged virtual memory]?

Security section: [https://en.wikipedia.org/wiki/DMA_attack DMA attack], [http://www.outsidaz.org/blog/2007/10/22/resetting-root-password-via-grubkernel-boot-options/ editing GRUB entries to gain root shell] without password prompt, [http://www.theinquirer.net/inquirer/news/2421402/serious-intel-cpu-security-exploit-spotted-in-old-x86-chips 20 years old security exploit in x86 processors].

=Lecture: Libraries, frameworks=

[https://echo360.e-ope.ee/ess/echo/presentation/26f1d40d-7830-4e5c-b783-e061c1e91cfc Lecture recording #1], from 00:27:30 up to 1:04:00.

[https://docs.google.com/presentation/d/1q9kGg5AI3AyXglxpJdLjLMpgRLdbF9dl62gauNmDEG8/edit Lecture slides]

Jargon: framework, library, [https://en.wikipedia.org/wiki/Application_binary_interface ABI], [https://en.wikipedia.org/wiki/Application_programming_interface API]

Security section: [http://www.fiercecio.com/story/hackers-exploiting-httpsys-bug-crash-iis-web-servers/2015-04-17 HTTP.sys bug crashes IIS web servers], [http://heartbleed.com/ OpenSSL bug Heartbleed].

=Lecture: Programming languages=

In this lecture we'll talk about programming languages

Lecture recording: [https://echo360.e-ope.ee/ess/echo/presentation/26f1d40d-7830-4e5c-b783-e061c1e91cfc starting from 1:04:00]

Lecture slides: [https://docs.google.com/presentation/d/1CCZntY7Z-AG_Mice5N2kclDGYI2xVVvRHgWUIs-SxYo/edit programming languages, stack machine]

Jargon: stack machine, lexer/lexeme, token, abstract syntax tree

Potential exam questions:

* What are the major steps of compilation?
* What are the differences between [https://en.wikipedia.org/wiki/Interpreted_language interpreted], [https://en.wikipedia.org/wiki/Just-in-time_compilation JIT-compilation] and [https://en.wikipedia.org/wiki/Compiler traditional compiling]?
* What is [https://en.wikipedia.org/wiki/Control_flow control flow]? Loops? Conditional statements?

Assignments:

* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Disassembling_Python Disassembling Python]
* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Investigating_compilers Investigating compilers]

=Lecture: Data encoding=

[https://echo360.e-ope.ee/ess/echo/presentation/ca8310e9-e82e-4e47-b90a-2e1801bcfada Lecture recording]

[https://docs.google.com/presentation/d/1QV_IMOadIEUTBW7Laqw59j8J7Y8HKwvSDmP-swEEx0s Lecture slides]

In this lecture we'll talk about bits, bytes, integers, strings, pixels, audio encodings, video encoding etc.

Potential exam questions:

* What is bit? Nibble? Byte? Word?
* Write 9375 in binary, hexadecimal?
* Write 0xDEADBEEF in decimal?
* What is [https://en.wikipedia.org/wiki/Quantization_%28signal_processing%29 quantization] in terms of signal processing?
* How are [https://en.wikipedia.org/wiki/Integer_%28computer_science%29 integers] stored in binary? What integer range can be described using n bits? How many bits are required to describe integer range from n .. m.
* How are [https://en.wikipedia.org/wiki/Single-precision_floating-point_format single precision] and [https://en.wikipedia.org/wiki/Double-precision_floating-point_format double precision] floating point numbers stored in binary according to [https://en.wikipedia.org/wiki/IEEE_floating_point IEEE754 standard]? [http://lauri.vosandi.com/hdl/arithmetic/floating-point-representation.html Floating-point multiplication]
* What is the difference between CMYK and RGB color models? How are YUV, HSV and HSL colorspaces related to RGB? What are sRGB and YCbCr and where are they used?
* How is data encoded on audio CD-s? What is the [http://lauri.vosandi.com/2013/07/audio-codecs.html capacity of an audio CD]?
* What is sampling rate? What is bit depth? What is resolution?
* What is bitrate?
* What is lossy/lossless compression?
* What is JPEG suitable for? Is JPEG lossy or lossless compression method?
* What is PNG suitable for? Does PNG support compression?
* How are time domain and frequency domain related in terms of signal processing? What is Fourier transform and where it is applied?

Jargon: 44.1kHz sampling rate, 16-bit audio, RGB565 pixel format, RGB888 pixel format

Relevant assignments:

* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Disassembling_Python Disassembling Python]
* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Investigating_compilers Investigating compilers]

=Lecture: Code execution in processor=

[https://docs.google.com/presentation/d/18wPDLydyZevMi9F0MX7F6eK-NMBZQzGN4mviF_ft8-E/edit Lecture slides]

[https://echo360.e-ope.ee/ess/echo/presentation/41440769-1cd5-4166-bd4e-299c2af3d3e0?ec=true Lecture recording #1]

[https://echo360.e-ope.ee/ess/echo/presentation/7aeb2a04-b0dc-4547-9dee-e541a5f9c99a?ec=true Lecture recording #2] up to 8:35, system calls

It's highly reccommended to play around with simulators [http://morriswmz.jit.su/static/simple-mips-pipelined.html here is one for MIPS processors].

In this lecture we'll talk about different processor architectures, instructions, pipelining, function calls, jumps, loops etc.

Assignments:

* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Disassembling_Python Disassembling Python]
* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Investigating_compilers Investigating compilers]

Exam question:

* Given ~10 instructions and their explainations, follow the instructions and elaborate after every step what happened in the processor?

=Lecture: Microcontrollers=

[https://docs.google.com/presentation/d/1qPyzBBfB1TseEzXjcp4-ZjqSnAwbjDmEqyIYcUGFLG0/edit Lecture slides]

[https://echo360.e-ope.ee/ess/echo/presentation/7aeb2a04-b0dc-4547-9dee-e541a5f9c99a?ec=true Lecture recording] starts at 8:35

Jargon: microprocessor, microcontroller, coprocessor, floating-point unit (FPU), digital signal processor (DSP), field programmable grid array (FPGA), sensors, actuators, digital input/output, analog input, general purpose input/output (GPIO), interrupt, interrupt handler, timer/counter, pulse-width modulation (PWM),

Potential exam question:

* What distinguishes microcontroller from microprocessor?
* What are the differences between Hardvard architecture and von Neumann architecture?
* What is an interrupt?
* What is an timer?

=Lecture: Introduction to Boole algebra=

[https://docs.google.com/presentation/d/1Y1rXvt2oXROhW-LZ07B0Sg90D-_u8SlLUZeaxds7f1g/ Lecture slides]

Exam questions:

* Simplify A AND A OR B
* Show addition of X and Y in binary
* Show subtraction of X and Y in binary
* Show multiplication of X and Y in binary

Assignments:
* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Designing_arithmetic-logic_unit Designing arithmetic-logic unit]

=Lecture: Hardware description languages=

[https://docs.google.com/presentation/d/1HO9iPfi8S3ZykuW7IHVm09QamLHiVo6s6lUGwWu4eD4/ Lecture slides]

[https://echo360.e-ope.ee/ess/echo/presentation/b7ca9eb3-5a9d-4e8c-8c1b-25c2891359ee Lecture recording] starts at 05:00

Potential exam questions:

* What are the uses for hardware description languages?
* What is latch?
* What is flip-flop?
* What is mux (multiplexer)?
* What is register? Register file?
* What is ALU?
* What is floating-point unit?
* What is a cache?
* What is a bus?
* Show the circuit diagram for A OR B AND C, NOT A AND B, <insert some other Boole formula here>?
* Show the truth table for <insert Boole formula here>?
* Write the equivalent Boole formula of a circuit diagram.

=Lecture: Publishing work=

[https://echo360.e-ope.ee/ess/echo/presentation/cd2c0e2b-5f48-4a39-89ca-b75801e5d00b Lecture recording]

[https://docs.google.com/presentation/d/1hCqRjGUx5Yv6iZN4xaz2UICLWbycnM46ctw2zX0g94U/ Lecture slides]

Potential exam questions:

* What are the major implications of MIT, BSD and GPL licenses?
* What are the differences between copyright, trademark, trade secret?
* Where would you use waterfall software development model? Where would you use agile?
* What is the purpose of a version control system?
* What would you store in a version control system?

=Lecture: Algorithms and data structures=

[https://echo360.e-ope.ee/ess/echo/presentation/1145600e-cef9-40b4-91da-3cc1174e27eb Lecture recording] unfortunately without audio :(

[https://docs.google.com/presentation/d/1vwJvvRerM0rYBaiE3pEX5GUXRHuVJvjTUDKo8fqTq_A/ Lecture slides]

Potential exam questions:

* What is time complexity of algorithm?
* What is space complexity of algorithm?
* What's a good algorithm?

=Lecture: History=

Topics: Computer history, Silicon Valley, standards

[https://echo360.e-ope.ee/ess/echo/presentation/584b21e6-4ead-4cb6-bc41-5c653bc5c3a2 Lecture recording]

[https://docs.google.com/presentation/d/1Ybld2ABpm9QJSLL-Bodr1a5XI5Hk_KM2q_nZVYu2L0c/edit?usp=sharing Lecture slides]

Potential example questions:

* What is [https://en.wikipedia.org/wiki/Moore's_law Moore's law]? What is [https://en.wikipedia.org/wiki/Rock's_law Rock's law]?
* What were the major contributing factors for success of Microsoft, Apple, Google, <your favourite company>?
* What were the major contributing factors to the success of Silicon Valley?

=Assignment: Investigating PC hardware=

Goal: Get familiar with your [https://en.wikipedia.org/wiki/X86 laptop hardware]. Get out of the comfort zone of your primary operating system and try out other operating systems. Learn about [https://en.wikipedia.org/wiki/Full_virtualization hardware virtualization].

Deadline: 16. September

Credits: 5 points plus extra point for being extra thorough about interpreting what you see.

Use what you learned in [[Getting started with Ubuntu]] workshop:

* '''Read the instructions before you act'''.
* Place your preferred ISO image to a memory stick using <code>dd</code> or Win32 Disk Imager and boot it on your personal laptop. You do '''not''' need to install Ubuntu on your harddisk, simply click '''Try Ubuntu''' once the operating system boots off the memory stick and carry out following tasks.
* Open up terminal by pressing <code>Ctrl-Alt-T</code>.
* Use <code>lsb_release -a</code> to check what operating system distribution you're running.
* Use <code>uname -sr</code> to check what operating system kernel you're running.
* Use <code>cat /proc/cpuinfo</code> and check processor information. What CPU model and how many cores your computer has?
* Use <code>arch</code> to check what CPU architecture is being used by the operating system. Is it 32-bit or 64-bit?
* Use <code>cat /proc/meminfo</code> to check memory usage. How much RAM your computer has?
* Use <code>lspci -t -v -nn</code> to enumerate PCI and PCI Express devices, attempt to identify what is what.
* Use <code>lsusb</code> and <code>lsusb -t</code> to enumerate USB devices, again attempt to identify what is what.
* Use <code>sudo fdisk -l</code> to enumerate disks and partitions. How big is your harddisk? How many and how big partitions it has?
* Use <code>lsblk</code> to enumerate block devices.
* Use <code>xrandr</code> to enumerate display outputs. What video output resolutions are available and which one is currently used?
* Use <code>cat /proc/asound/cards</code> to check which audio devices are available.
* Use <code>dmidecode</code> to see even more information about your computer.
* Use <code>ifconfig -a</code> or <code>ip addr list</code> to list all network interfaces.
* Use <code>iwconfig</code> or <code>iw list</code> to list all wireless network interfaces. Is your wireless network interface detected? If not take a guess why?
* Use <code>hcitool dev</code> to list bluetooth host controller. Is your bluetooth device detected?
* Use <code>glxinfo</code> to check what 3D rendering capabilities are available, is it hardware accelerated? (hint: is direct rendering enabled?)
* What [https://en.wikipedia.org/wiki/Sound_card audio card] is your machine using? What bus is it using?
* What [https://en.wikipedia.org/wiki/Graphics_processing_unit graphics controller] is your machine using? What bus is it using?
* What webcam is your machine using? What bus is it using?
* What [https://en.wikipedia.org/wiki/Ethernet wired network] chipset your computer has? What bus is it using?
* What [https://en.wikipedia.org/wiki/IEEE_802.11 wireless network] chipset your computer has? What bus is it using?
* What [https://en.wikipedia.org/wiki/Bluetooth Bluetooth] device your computer has? What bus is it using?
* Is there a [https://en.wikipedia.org/wiki/Mobile_broadband_modem cellular modem] connected and how it's connected?
* Boot the ISO image in VirtualBox and follow the same steps as above, '''what are the differences and why'''?
* Answer to questions above and send it as [https://en.wikipedia.org/wiki/Plain_text plain text] e-mail to Lauri, make sure you '''use the address supplied above with the course code''', otherwise your mail is not searchable in my mailbox. Attach collected command outputs as [https://en.wikipedia.org/wiki/Plain_text plain text] file, do '''not''' send .odt, .doc files, these are not readable on my smartphone. When answering to questions phrase the text in a way that is understandable out of context, so I don't have to open up wiki to understand what you're talking about.

Note that I can't expect you to install Ubuntu on your physical machine, but I can help if you want to do that. You should have Ubuntu ready to go in a virtual machine at least for subsequent sessions. We're using Ubuntu because it's widely used on servers and in the cloud, so any Ubuntu skills will definitely come handy in future. If you're already familiar with Linux, it's suggested to take a look at other interesting operating systems such as [https://www.freebsd.org/ FreeBSD] or [http://www.openbsd.org/ OpenBSD]. Take a look at [https://www.kali.org/ Kali Linux] if you're interested in penetration testing.

=Assignment: Investigating embedded hardware=

Background: Most of the smartphones nowadays are using [https://en.wikipedia.org/wiki/System_on_a_chip SoC] built around [https://en.wikipedia.org/wiki/ARM_architecture ARM] processor. Raspberry Pi is an excellent piece of hardware to for checking out how an ARM-based machine looks like.

Goal: Get familiar with hardware ARM-based hardware.

Deadline: 23. September

Points: 4 points

Use what you learned in [[Getting started with Ubuntu]] and [[Getting started with Raspberry Pi]] workshops:

* Read the instructions before you get busy.
* Boot Raspbian on Raspberry Pi.
* Use the commands described in previous assignment to examine the environment of Raspbian on Raspberry Pi. What are the major differences compares to your laptop and virtual machine?
* What buses is Raspberry Pi making use of?
* What filesystems is Raspbian making use of?
* Answer to questions above and send it as e-mail to Lauri, make sure you '''use the address supplied above with the course code''', otherwise your mail is not searchable in my mailbox. Attach collected command outputs as [https://en.wikipedia.org/wiki/Plain_text plain text] file, do '''not''' send .odt, .doc files, these are not readable on a phone. When answering to questions phrase the text in a way that is understandable out of context, so it is not necessary to open up wiki to understand what you're talking about.

=Assignment: Investigating LAMP=

[https://en.wikipedia.org/wiki/LAMP_%28software_bundle%29 LAMP] software bundle is consists of Linux-based OS, [https://en.wikipedia.org/wiki/Apache_HTTP_Server Apache web server], [https://en.wikipedia.org/wiki/PHP PHP programming language] runtime and [https://en.wikipedia.org/wiki/MySQL MySQL database].
Most of the web applications on the Internet including Facebook are built on top of LAMP-styled software stack.
Use a Raspberry Pi or Ubuntu virtual machine to set up [https://www.raspberrypi.org/learning/lamp-web-server-with-wordpress/ WordPress], [https://doc.owncloud.org/server/8.1/admin_manual/installation/index.html ownCloud] or any well-known web application that makes use of a database such as MySQL.
To make your life easier also set up SSH public key authentication.

Goal: Get familiar with LAMP stack. Get comfortable with (SSH) public key authentication.

Deadline: 30. September

Points: 4 points

Tasks:

* If you're using Ubuntu virtual machine approach, see [[Accessing a virtual machine via SSH connection]]
* Use SSH to connect to your server over the network. If you're using Windows on your laptop use [http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY] to gain access to command line and [https://winscp.net/ WinSCP] to copy files, otherwise simply boot Ubuntu in a virtual machine and use <code>ssh username@hostname</code> to invoke commands and <code>sftp://username@hostname</code> in the file browser to access filesystem.
* Set up any of the web applications referenced above. You may be interested in reading also [http://howtoubuntu.org/how-to-install-lamp-on-ubuntu this] and [https://www.digitalocean.com/community/tutorials/how-to-install-wordpress-on-ubuntu-14-04 this].
* Demonstrate that the web application you installed works in next Tuesday session, screenshots/photos with explanation sent to e-mail above also suffice.
* Optional: Set up SSH public key authentication to <code>enos.itcollege.ee</code>.
* Optional: [https://www.raspberrypi.org/documentation/remote-access/ssh/passwordless.md Set up public key authentication to your Raspberry Pi]. Windows users might want to take a look at [https://winscp.net/eng/docs/ui_puttygen#obtaining_and_starting_puttygen PuTTYgen instructions].

Note: You don't have to necessarily use Raspberry Pi - Web application installed in Ubuntu VM is also accepted, also if you're maintaining similar installation of a production server that is accepted as well. [http://www.wampserver.com/en/ WAMP] on Windows is also accepted.

=Assignment: Set up basic IoT scenario=

[https://en.wikipedia.org/wiki/Internet_of_Things Internet of Things] is one of the emerging technologies (read: hype). IoT is essentially about getting everything online, including lightbulbs, switches, window shades etc. In this assignment LED symbolizes a light and the task is to implement code which allows user to switch the LED on and off over the network.

[[File:Raspberry-pi-gpio-18-led bb.png|600px]]

Goal: Get familiar how Python code can be started up. Build basic [https://en.wikipedia.org/wiki/Internet_of_Things IoT] appliance, a light that can be turned on and off via the Internet.

Deadline: 7. October

Points: 4 points

* Complete the [http://codeacademy.com/tracks/python Python track at CodeAcademy] if you haven't done that yet.
* Follow the wiki page Blinking LED section under [[Getting started with Raspberry Pi]].
* Get an LED blinking on command-line.
* Get LED blinking from Python code.
* Get basic HTTP server running in Python.
* Combine all of the above, build an HTTP server that can be used to turn LED on and off from via web browser.
* Optional: Take a peek at next assignment and upload working version to GitHub.
* Optional: [http://sourceforge.net/p/raspberry-gpio-python/wiki/PWM/ Smoothen the transitions using PWM].

=Assignment: Collaborating using Git=

Software development is usually done by several contributors, to facilitate efficient collaboration a distributed version control system is a must. In this assignment you'll upload your code to GitHub and modify fellow student's code to reflect changes in the Raspberry Pi setup:

[[File:Raspberry-pi-rgb-led bb.png|600px]]

Deadline: 14. October

Points: 5

Goal: Get familiar with distributed version control systems. Collaborate.

* Create [https://github.com/ GitHub] account if you haven't done so yet.
* Create a Git repository, eg http://github.com/your-username/rpi-iot-example
* Install Git on your Raspberry Pi by using <code>apt-get install git</code>.
* Clone the repository to your Raspberry Pi using <code>git clone http://github.com/your-username/rpi-iot-example</code>.
* Move the Python code created earlier to the Git repository directory.
* Use <code>git add</code> to add the files.
* Configure full name: <code>git config --global user.name "Firstname Surname"</code>
* Configure e-mail: <code>git config --global user.email first.last@domain.tld</code>
* Use <code>git commit</code> to create the [http://blog.no-panic.at/2014/10/20/funny-initial-git-commit-messages/ initial commit].
* Use <code>git push</code> to push the commits to GitHub server.
* Set up [https://help.github.com/articles/generating-ssh-keys/ public key authentication between your laptop and GitHub servers], verify that <code>https://github.com/username.keys</code> gives the expected result.
* Use <code>git clone</code> to clone the repository to your laptop. Ubuntu should first <code>apt-get install git</code>, Windows and Mac users might want to take a look at [http://git-scm.com/download/ Git homepage]. If you're looking for graphical user interface take a look at [https://desktop.github.com/ GitHub Desktop] or [https://tortoisegit.org/ TortoiseGit].
* Create [https://en.wikipedia.org/wiki/README README] in the repository directory, populate it with relevant content - what is it about, who made it etc and commit the changes.
* In your Raspberry Pi setup replace the single-color LED with RGB LED as shown above.
* Clone '''fellow student's''' repository and adapt the code to reflect physical changes to the setup, the Python snippet should now permit changing the color of the light, have it blinking and turn it off. Other interesting modes are awarded with extra points.
* Use either [https://www.atlassian.com/git/tutorials/ Atlassian Tutorials], [http://rogerdudler.github.io/git-guide/ git - the simple guide] or [https://try.github.io/ Try Git] as a reference if you get lost.
* Document in the README what GPIO pins are used in the code for red, green and blue. Extra points for making the Python code [https://docs.python.org/2/library/argparse.html#module-argparse configurable from command-line].
* Late submissions will heavily lose points for failure to comply with [http://chris.beams.io/posts/git-commit/ decent commit messages].
* Send Lauri the URL of your repository at GitHub.

Git resources: [http://git-scm.com/book/en/v2 Pro Git Book] (read the basics to get kickstarted) and [https://www.codecademy.com/en/courses/learn-git/ Codecademy Git course].

=Assignment: Disassembling Python=

CPython is the default, most widely used implementation of the Python programming language. CPython is written in C. CPython compiles Python source into bytecode which is interpreted by a Python virtual (stack) machine. This is very similar to what is done with Java. Use [https://docs.python.org/2/library/dis.html dis] to disassemble a Python function into stack machine instructions. Follow [https://docs.python.org/2/library/dis.html#python-bytecode-instructions bytecode instructions] to determine what each instruction does.

Deadline: 21. October

==Example submission==

Consider following Python function, which calculates the sum of squares. For example sum_of_powers(2, 3) == 14 (1**2 + 2**2 + 3**2):

def sum_of_powers(exponent, numbers):
counter = 1
return_value = 0
while True:
if counter > numbers:
break
return_value += counter ** exponent
counter += 1
return return_value

# Following two lines are the ones which produce the instructions shown below
from dis import dis
dis(sum_of_powers)

Corresponding Python stack machine instructions extracted with <code>dis</code> are following. Columns correspond to: line number in the source code, instruction offset (in bytes), instruction name as listed [https://docs.python.org/2/library/dis.html in dis documentation],

22 0 LOAD_CONST 1 (1) # Constant of 1 is pushed to stack
3 STORE_FAST 2 (counter) # Pushed value is popped and stored in variable counter

23 6 LOAD_CONST 2 (0) # Constant of 0 is pushed to stack
9 STORE_FAST 3 (return_value) # Pushed value is popped and stored in variable return_value

24 12 SETUP_LOOP 43 (to 58) # Loop until instruction no 58 is set up

25 >> 15 LOAD_FAST 2 (counter) # Value of variable <counter> is pushed to stack
18 LOAD_FAST 1 (numbers) # Value of variable <numbers> is pushed to stack
21 COMPARE_OP 4 (>) # Two topmost values of stack are popped and compared,
# boolean result is pushed back to the top of stack
24 POP_JUMP_IF_FALSE 31 # If top of the stack if False,
# jump to instruction no 31 is performed.
# Top of the stack is popped

26 27 BREAK_LOOP # Execution jumps out of the loop, the one
# that was set up at inst no 12
28 JUMP_FORWARD 0 (to 31) # Placeholder probably due to the way pipeline is handled

27 >> 31 LOAD_FAST 3 (return_value) # Value of variable <return_value> is pushed to stack
34 LOAD_FAST 2 (counter) # Value of variable <counter> is pushed to stack
37 LOAD_FAST 0 (exponent) # Value of variable <exponent> is pushed to stack
40 BINARY_POWER # Exponentiation of two topmost values is performed and
# substituted with the result
41 INPLACE_ADD # Two topmost values are added and substituted with the sum
42 STORE_FAST 3 (return_value) # Sum of the addition is stored in variable <return_value>

28 45 LOAD_FAST 2 (counter) # Value of variable <counter> is pushed to stack
48 LOAD_CONST 1 (1) # Constant of 1 is pushed to stack
51 INPLACE_ADD # Two topmost values are added and substituted with the sum
52 STORE_FAST 2 (counter) # Sum is stored in the variable <counter>
55 JUMP_ABSOLUTE 15 # Code execution jumps to instruction no 15 (the beginning of the loop)

29 >> 58 LOAD_FAST 3 (return_value) # The value of variable <return_value> is pushed to stack
61 RETURN_VALUE # Return top of the stack to the function caller

In the Python VM the state consists of:

* Program counter (PC), the number of currently executed instruction
* The stack and most importantly top of stack (TOS)
* Constants extracted from source (co_consts)
* Variables names (co_names)
* Variables values (co_varnames)
* There are *no* registers!

Executing the function with arguments exponent=2 and numbers=3 will result in return value of 14, the arguments are already placed in the co_varnames array by the calling function. Also the constants used in the code are present, so you may assume following state in the Python interpreter just before entering the function body:

-1. stack = []; co_varnames = [2, 3]; co_consts[?, 1, 0]

The steps that Python VM takes to get to the results are following:

0. LOAD_CONST 1: stack = [1]
3. STORE_FAST 2: stack = []; co_varnames = [2, 3, 1]
6. LOAD_CONST 2: stack = [0];
9. STORE_FAST 3: stack = []; co_varnames = [2, 3, 1, 0]
12. SETUP_LOOP 43: stack = []; loop is set up, counter is 1

Here we enter loop body for the first time

15. LOAD_FAST 2: stack = [1]
18. LOAD_FAST 1: stack = [1, 3]
21. COMPARE_OP 4: stack = [False]
24. POP_JUMP_IF_FALSE 31: stack = []; jump to instruction 31
31. LOAD_FAST 3: stack = [0];
34. LOAD_FAST 2: stack = [0, 1];
37. LOAD_FAST 0: stack = [0, 1, 2];
40. BINARY_POWER: stack = [0, 1]
41. INPLACE_ADD: stack = [1]
42. STORE_FAST 3: stack = []; co_varnames = [2, 3, 1, 1]
45. LOAD_FAST 3: stack = [1];
48. LOAD_CONST 1: stack = [1, 1];
51. INPLACE_ADD: stack = [2]
52. STORE_FAST 2: stack = []; co_varnames = [2, 3, 2, 1]
53. JUMP_ABSOLUTE 15: jump to instruction no 15, counter is 2

Here we enter loop body for the second time

15. LOAD_FAST 2: stack = [2]
18. LOAD_FAST 1: stack = [2, 3]
21. COMPARE_OP: stack = [False]
24. POP_JUMP_IF_FALSE 31: stack = []; jump to instruction 31
31. LOAD_FAST 3: stack = [1]; here we have only 1**1
34. LOAD_FAST 2: stack = [1, 2];
37. LOAD_FAST 0: stack = [1, 2, 2];
40. BINARY_POWER: stack = [1, 4]
41. INPLACE_ADD: stack = [5]; here we already have 1**2 + 2**2
42. STORE_FAST 3: stack = []; co_varnames = [2, 3, 2, 5]
45. LOAD_FAST 3: stack = [2];
48. LOAD_CONST 1: stack = [2, 1];
51. INPLACE_ADD: stack = [3]
52. STORE_FAST 2: stack = []; co_varnames = [2, 3, 3, 5]
53. JUMP_ABSOLUTE 15: jump to instruction no 15, counter is 3

Here we enter the loop body third time

15. LOAD_FAST 2: stack = [3]
18. LOAD_FAST 1: stack = [3, 3]
21. COMPARE_OP: stack = [False]
24. POP_JUMP_IF_FALSE 31: stack = []; jump to instruction 31
31. LOAD_FAST 3: stack = [5]
34. LOAD_FAST 2: stack = [5, 3];
37. LOAD_FAST 0: stack = [5, 3, 2];
40. BINARY_POWER: stack = [5, 9]
41. INPLACE_ADD: stack = [14]; here we have 1**2 + 2**2 + 3**2
42. STORE_FAST: stack = []; co_varnames = [2, 3, 3, 14]
45. LOAD_FAST 3: stack = [3];
48. LOAD_CONST 1: stack = [3, 1];
51. INPLACE_ADD: stack = [4]
52. STORE_FAST 2: stack = []; co_varnames = [2, 3, 4, 14]
53. JUMP_ABSOLUTE 15: jump to instruction no 15, counter is 4

Here we enter the loop body fourth (!!!) time

15. LOAD_FAST 2; stack = [4]
18. LOAD_FAST 1; stack = [4, 3]
21. COMPARE_OP 4; stack = [True]
24. POP_JUMP_IF_FALSE 31; stack = []; but the condition does not hold anymore so we jump out of the loop
27. BREAK_LOOP; break out of the loop
58. LOAD_FAST 3; stack = [14]
61. RETURN_VALUE; return 14 to caller

==Assignment steps==

# Select one of the Fibonacci code examples below.
# Use <code>from dis import dis</code> and <code>dis(function_name_goes_here)</code> to disassemble the function to opcodes.
# Comment the stack machine instructions as shown above (3p).
# Invoke the Fibonacci number calculation function with n=2, follow the instructions and elaborate after each instruction executed a) the stack contents b) co_varnames contents c) co_names contents d) what happened as shown above. Note that certain code blocks will be executed repeatedly, which means you'll have more than '''30 instructions executed''' (2p).

Fibonacci with iterators:

<pre>
def fib(n):
a,b = 1,1
for i in range(n-1):
a,b = b,a+b
return a
</pre>

Fibonacci with recursion:

def fib(n):
if n==1 or n==2:
return 1
return fib(n-1) + fib(n-2)

Fibonacci with infinite loop and breaks:

def fib3(n):
a,b,i = 1,1,0
while True:
i += 1
if i >= n: break
b,a = a+b,b
return a

Another variation:

def fib4(n):
a = 1
b = 1
i = 0
while True:
i += 1
if i >= n: break
s = a + b
a = b
b = s
return a

=Assignment: Investigating compilers=

Use what you learned in the [https://wiki.itcollege.ee/index.php/Getting_started_with_GCC Getting started with GCC] session.
See assignment steps below.
Everything you need to understand ARM instructions should be [http://aelmahmoudy.users.sourceforge.net/electronix/arm/chapter2.htm here].
Another good resource seems to be [http://www.davespace.co.uk/arm/introduction-to-arm/ Introduction to ARM] by David Thomas.
See page 14 of [http://infocenter.arm.com/help/topic/com.arm.doc.ihi0042e/IHI0042E_aapcs.pdf Procedure Call Standard for the ARM® Architecture] if you want to learn more about how function calls are implemented on ARM.
See [http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0204j/Cihfddaf.html here] for more information about branching instructions: B, BL, BX.
<Insert extemely useful link here yourself>

Deadline: 4. November

==Example==

If you don't have Ubuntu installed on your machine skip next step and use SSH to perform these steps remotely at <code>enos.itcollege.ee</code>.
Otherwise install ARM cross-compiler:

apt-get install gcc-arm-linux-gnueabi

Consider C snippet for calculating integer [https://en.wikipedia.org/wiki/Exponentiation exponentiation], place it in a file <code>power.c</code>:

int power(long base, long exponent) {
int counter;
int result = 1;
for (counter = 0; counter < exponent; counter++)
result *= base;
return result;
}

===Generating assembly===

Compile ARM assembly of the code snippet:

arm-linux-gnueabi-gcc -Os -S power.c -o power.s # Cross-compile ARM assembly file power.s from C source code file power.c
cat power.s # Dump the assembly file on terminal

The compiler should produce something similar to following:

.arch armv5t
.fpu softvfp
.eabi_attribute 20, 1
.eabi_attribute 21, 1
.eabi_attribute 23, 3
.eabi_attribute 24, 1
.eabi_attribute 25, 1
.eabi_attribute 26, 2
.eabi_attribute 30, 2
.eabi_attribute 34, 0
.eabi_attribute 18, 4
.file "power.c"
.text
.align 2
.global power
.type power, %function
power:
@ args = 0, pretend = 0, frame = 0
@ frame_needed = 0, uses_anonymous_args = 0
@ link register save eliminated.
cmp r1, #0
mov r2, #1
ble .L2
mov r3, #0
.L3:
add r3, r3, #1
cmp r3, r1
mul r2, r0, r2
bne .L3
.L2:
mov r0, r2
bx lr
.size power, .-power
.ident "GCC: (Ubuntu/Linaro 4.7.3-12ubuntu1) 4.7.3"
.section .note.GNU-stack,"",%progbits

===Commenting the assembly===

You can safely ignore the lines starting with dot, these are simply hints for the next stage of the compilation process.
Thus you're left only (!!!) 10 actual instructions. Here you can also see what kind of comments are expected from the submission:

power:
cmp r1, #0 /* Compare register r1 (second argument) contents against constant 0 */
mov r2, #1 /* Copy the constant 1 to register r2 */
ble .L2 /* Jump to label .L2 if the comparison was false */
mov r3, #0 /* Copy the constant 0 to register r3 */
.L3:
add r3, r3, #1 /* Perform r3 = r3 + 1 */
cmp r3, r1 /* Compare register r3 and r1 (second argument) */
mul r2, r0, r2 /* Perform r2 = r0 (first argument) * r2 */
bne .L3 /* If r3 and r1 were different jump to label .L3
.L2:
mov r0, r2 /* Copy register r2 contents to register r0 */
bx lr /* Jump back to caller */

===Analyzing the code===

Code analysis reveals that registers are mapped as following:

* <code>r0</code> - argument <code>base</code> and eventually return value
* <code>r1</code> - argument <code>exponent</code>
* <code>r2</code> - variable <code>result</code>
* <code>r3</code> - variable <code>counter</code>

We can also see how the <code>for</code> loop gets translated into assembly:

power:
cmp r1, #0
mov r2, #1
ble .L2
mov r3, #0
.L3:
add r3, r3, #1 <---+
cmp r3, r1 | 4 instructions are executed repeatedly
mul r2, r0, r2 | if exponent is greater than 0
bne .L3 -----------+
.L2:
mov r0, r2
bx lr

===Stepping through the instructions===

When we execute the function with for example arguments base=5 and exponent=3 following happens in the processor.
Note that this will essentially calculates 5 ^ 3 (5 to the power of 3) which is 125.
Following has been done manually to illustrate how much time does it take to execute the the function.

/* When processor enters the function body the arguments are already placed in registers r0=5 (base), r1=3 (exponent) */
cmp r1, #0 /* Compare exponent to 0 */
mov r2, #1 /* Place constant 1 in register r2,
this corresponds to result = 1 in C code */
ble .L2 /* Exponent was not less than 0, so no jump to L2
mov r3, #0 /* Place constant 0 in register r3,
this corresponds to variable counter */

add r3, r3, #1 /* Perform r3 = 0 + 1 which results in 1 being stored to r3
this corresponds to first invocation of counter++ in C code */
cmp r3, r1 /* Compare counter (1 in this case) to exponent (3), this will be used by bne instruction below */
mul r2, r0, r2 /* Perform r2 = r0 * r2 which results in 1 * 5 = 5 being placed in r2
this corresponds to first invocation of result *= base in C code */
bne .L3 /* The comparison resulted in counter being not equal to exponent, so we jump back to L3
this corresponds to first invocation of counter < exponent in C code */

add r3, r3, #1 /* Perform r3 = 1 + 1 which results in 2 being stored to r3
this corresponds to second invocation of counter++ in C code */
cmp r3, r1 /* Compare counter (2 in this case) to exponent (3), this will be used by bne instruction below */
mul r2, r0, r2 /* Perform r2 = r0 * r2 which results 5 * 5 = 25 being placed in r2
this corresponds to second invocation of result *= base in C code */
bne .L3 /* The comparison resulted in counter being not equal to exponent, so we jump back to L3
this corresponds to second invocation of counter < exponent in C code */

add r3, r3, #1 /* Perform r3 = 2 + 1 which results in 3 being stored to r3
this corresponds to third invocation of counter++ in C code */
cmp r3, r1 /* Compare counter (3 in this case) to exponent (3), this will be used by bne instruction below */
mul r2, r0, r2 /* Perform r2 = r0 * r2 which results 25 * 5 = 125 being placed in r2
this corresponds to third invocation of result *= base in C code */
bne .L3 /* The comparison resulted in counter being equal to exponent, so we DO NOT jump back to L3 */

mov r0, r2 /* Copy register r2 contents (125) to register r0 */
bx lr /* Jump back to caller */
/* Function returns with 125 placed in r0 this is where caller function should expect the return value */
/* The other registers will still hold whatever values were left there: r1 = 3, r2 = 125, r3 = 3 */

===ARM registers===

If you get lost with the ARM register naming conventions use following as a guide.

ARM7 has 16x 32-bit registers:

r0 (a1) - Argument/result/scratch register, this is where first function argument is usually placed
r1 (a2) - Argument/result/scratch register, this is where second function argument is placed
r2 (a3) - Argument/scratch register 3
r3 (a4) - Argument/scratch register 4
r4 (v1) - Variable register 1
r5 (v2) - Variable register 2
r6 (v3) - Variable register 3
r7 (v4) - Variable register 4
r8 (v5) - Variable register 5
r9 (v6) - Variable register 6
r10 (v7) - Variable register 7
r11 (fp) - Frame pointer, variable register 8
r12 (ip) - Intra-procedure call scratch register
r13 (sp) - Stack pointer
r14 (lr) - Link register (to which memory address currently
executing function should return to?)
r15 (pc) - Program counter (what is the memory address of instruction
^ that we are going to execute next?)
|
+- These are simply aliases for the numbered registers and
can be used interchangeably.

==Assignment steps==

# Select one of the Fibonacci calculation examples below and use ARM cross compiler as shown above to generate the assembly corresponding to the C source code (1p).
# Remove the compiler hints (lines starting with dot), this should leave you less than 20 instructions. If it's more than that try different optimization flags. Analyze and comment the assembly as shown above (1p).
# Use n=3 as argument and follow the instructions, what values are left in the registers after the function finishes (2p)?
# Optional/extra: Elaborate step by step what happens in the processor: what instruction is being executed and what values are left in registers after instruction finishes? (1p)
# Optional/extra: Recompile with different optimization levels: <code>-Os</code>, <code>-O0</code>, <code>-O1</code>, <code>-O2</code> and <code>-O3</code>. What differences did you notice? (1p)
# Optional/extra: Take a guess which one of the Fibonacci calculation functions below is the slowest? Which one is the fastest? Why? (1p)
# Send your conclusions as e-mail attachment to Lauri, attach the commented assembly, make sure you '''use the address supplied above with the course code''', otherwise your mail is not searchable in my mailbox.

Fibonacci calculation using <code>for</code>-loop:

int fib(n) {
int a = 1;
int b = 1;
int i;
for (i = 0; i < n; i++) {
int s = a + b;
a = b;
b = s;
}
return a;
}

Fibonacci calculation using recursion:

int fib2(n) {
if (n == 1 || n== 2) {
return 1;
} else {
return fib(n-1) + fib(n-2);
}
}

Fibonacci calculation using <code>while</code>-loop:

int fib4(n) {
int a = 1;
int b = 1;
int i = 0;
while(1) {
i += 1;
if (i >= n) { break; }
int s = a + b;
a = b;
b = s;
}
return a;
}

=Assignment: Investigating microcontrollers=

In this assignment we use Arduino to implement traffic lights for [http://www.nobleled.com/uploads/110833/100_101.jpg crossroads].
If you don't care much about doing this assignment hands on, you can give a try [https://123d.circuits.io/ online].

==Assignment steps==

* Install Arduino IDE on your personal machine, on Windows/Mac check out [https://www.arduino.cc/ Arduino homepage] for instructions, on Ubuntu <code>apt-get install arduino</code> should suffice. You can also use school computers, Ubuntu has Arduino preinstalled.
* From Arduino IDE menu open up File -> Examples -> 01. Basic -> Blink
* In Arduino IDE menu Tools -> Board -> Arduino Mega2560
* In Arduino IDE menu Tools -> Serial port -> Select what makes sense
* On Ubuntu you may have to add yourself to the dialout group before you can access the serial ports. Use the command <code>sudo gpasswd -a $USER dialout</code>, log out and log in again to your PC.
* Press the second button in the toolbar to upload the code, make sure the changes take effect on the board. You should see on-board LED blinking.
* Connect some LED-s to the board. '''MAKE SURE YOU USE RESISTORS TO PROTECT LED-s AND THE BOARD'''
* Implement traffic light cycle using <code>digitalWrite</code> and <code>delay</code> in the <code>loop</code> function (3p)
* Use interrupts to read button presses, see example below. Pressing the button should toggle the LED now (1p)
* Extra: Use [https://www.arduino.cc/en/Reference/AnalogWrite PWM] to implement smoother blinking (1p)
* Extra: Use [http://lauri.vosandi.com/arduino/lcd1602-key-shield.html LCD1602] shield to display countdown (1p)
* Use [https://www.arduino.cc/en/Reference/Serial serial] interface to send messages to your PC.
* You can find useful code snippets for Robotics club equipment [http://lauri.vosandi.com/arduino here]

==Code example: reading button press with interrupts==

Set up a push button as shown below:

[[File:Arduino-pushbutton_bb.png|500px]]

Insert following code to Arduino IDE and upload it to Arduino, verify that it works:

int led = 13;
int button = 2;
int flag = LOW;

void setup() {
pinMode(led, OUTPUT); // Set up pin 13 as digital output
pinMode(button, INPUT_PULLUP); // Set up pin 9 as digital input with pull-up resistor enabled

// Associate interrupt handler with an event
attachInterrupt(digitalPinToInterrupt(button), onButtonPressed, FALLING);
}

void onButtonPressed() {
// Keep this as short as possible
flag = HIGH;
}

void loop() {
// Do something useful or let processor sleep here
if (flag) {
digitalWrite(led, HIGH);
delay(2000);
flag = LOW;
}

digitalWrite(led, LOW);
delay(50);
}

==Code example: Cycling through different traffic light states==

Add LED-s to the design:

[[File:Traffic-lights_bb.png|500px]]

Use following as hint to implement cycling through traffic light states:

// Define pin numbers
int car_green = 5;
int car_yellow = 6;
int car_red = 7;

// For LED-s we're sinking the 5V voltage, hence LED is turned on when voltage on the pin is LOW
int on = LOW;
int off = HIGH;

void setup() {
pinMode(car_green, OUTPUT);
pinMode(car_yellow, OUTPUT);
pinMode(car_red, OUTPUT);
digitalWrite(cars_yellow, off);
Serial.begin(9600);
}

void loop() {
Serial.println("Cars green, pedestrians red for 5 seconds");
digitalWrite(cars_red, off);
digitalWrite(cars_green, on);
delay(5000);

Serial.println("Green for cars is blinking 5 seconds");
for(int j = 0; j < 10; j++) {
digitalWrite(cars_green, j % 2 == 0);
delay(500);
}

Serial.println("Cars red, pedestrians green for 5 seconds");
digitalWrite(cars_green, off);
digitalWrite(cars_red, on);
delay(5000);
}

==Skeleton of the final submission==

The real traffic light has of course a little bit more states:

1. Cars green, pedestrians red for 10 seconds
2. Cars green **blinking**, pedestrians red for 2 seconds
3. Cars red, pedestrians green for 10 seconds
4. Cars red, pedestrians green **blinking** for 2 seconds
5. Cars yellow, pedestrians red for 2 seconds

So your final code will look something like this:

// Define pin numbers here

// Initially the flag is low
int pedestrian_requested_crossing = LOW;

void setup() {
// Initialize necessary pins as digital outputs
// Reset pins with digitalWrite

// Initialize button pin as digital input
// Enable pull-up resistor on button pin
// Associate button interrupt handler function (onButtonPressed) below with the event on the button

}

void onButtonPressed() {
// Here set pedestrian_requested_crossing flag to HIGH
// Don't do anything else here!
}

void loop() {
Serial.println("Cars green, pedestrians red for 5 seconds");
digitalWrite(cars_red, off);
digitalWrite(cars_green, on);
// Set pedestrian lights here
delay(5000);

if (pedestrian_requested_crossing) {

Serial.println("Green for cars is blinking 5 seconds");
for(int j = 0; j < 10; j++) {
digitalWrite(cars_green, j % 2 == 0);
delay(500);
}

Serial.println("Cars red, pedestrians green for 5 seconds");
digitalWrite(cars_green, off);
digitalWrite(cars_red, on);
// Set pedestrian lights here
delay(5000);

// Add another state here

// And another state here

// Reset flag here
}
}

=Assignment: Adders with NAND gates=

In this assignment we use chips to build an adder. Get max points (4p) by wiring up half adder and double your points (8p) if you can make full adder work as well :)

[[File:53-7400n-detailed.png]]

Each SN74HC03N chip contains four NAND gates arranged like this, observe the pit on the left. VCC corresponds to 5V power supply and GND corresponds to ground or 0V.

==Half adder==

Each [http://www.ti.com/lit/gpn/sn74hc03 SN74HC03] contains 4 NAND gates.
Use breadboard to wire up half adder with 7400 chips (4p):

[[File:Half-adder_bb.png|700px]]

The truth table for half adder:

A | B | Cout | Sum | Human readable (how many bits are high?)
-----+-----+------+------+-------------------------------------------
0 | 0 | 0 | 0 | 0
-----+-----+------+------+-------------------------------------------
0 | 1 | 0 | 1 | 1
-----+-----+------+------+-------------------------------------------
1 | 0 | 0 | 1 | 1
-----+-----+------+------+-------------------------------------------
1 | 1 | 1 | 0 | 2

==Full adder==

You can double your points if you manage to wire up a full adder (+4p)

[[File:Nand-full-adder.png]]

On a breadboard it looks a bit messy, but if you pay attention to gate numbering as shown above it should make your life significantly easier.
The gates 1, 2, 3, 4 are placed in the leftmost chip; 5, 6, 7, 8 are placed in the middle one and gate 9 is the only one in the rightmost chip:

[[File:Full-adder_bb.png|700px]]

A | B | Cin | Cout | Sum | Human readable (how many bits are high?)
-----+-----+-----+------+------+-------------------------------------------
0 | 0 | 0 | 0 | 0 | 0
-----+-----+-----+------+------+-------------------------------------------
0 | 0 | 1 | 0 | 1 | 1
-----+-----+-----+------+------+-------------------------------------------
0 | 1 | 0 | 0 | 1 | 1
-----+-----+-----+------+------+-------------------------------------------
0 | 1 | 1 | 1 | 0 | 2
-----+-----+-----+------+------+-------------------------------------------
1 | 0 | 0 | 0 | 1 | 1
-----+-----+-----+------+------+-------------------------------------------
1 | 0 | 1 | 1 | 0 | 2
-----+-----+-----+------+------+-------------------------------------------
1 | 1 | 0 | 1 | 0 | 2
-----+-----+-----+------+------+-------------------------------------------
1 | 1 | 1 | 1 | 1 | 3

==Unittest==

Use following code snippet on Arduino to test the circuit, it will shuffle through all the possible inputs and test whether the expected output is on the output pins.
If you see <code>sum</code> or <code>cout</code> outputs giving 0 all the time it's likely you have resistors of too low resistance in the circuit which is draining all the voltage on the NAND gate output pins.

int PIN_A = 2;
int PIN_B = 3;
int PIN_CIN = 4;
int PIN_SUM = 5;
int PIN_COUT = 6;

void setup() {
// Set up serial
Serial.begin(9600);

// Set up operands
pinMode(PIN_A, OUTPUT);
pinMode(PIN_B, OUTPUT);
pinMode(PIN_CIN, OUTPUT);
digitalWrite(PIN_A, HIGH);
digitalWrite(PIN_B, HIGH);
digitalWrite(PIN_CIN, HIGH);

// Set up measurement pins
pinMode(PIN_SUM, INPUT_PULLUP);
pinMode(PIN_COUT, INPUT_PULLUP);
}

void test(int a, int b, int cin) {
int cout = a && b || a && cin || b && cin;
int sum = a ^ b ^ cin;

digitalWrite(PIN_A, a);
digitalWrite(PIN_B, b);
digitalWrite(PIN_CIN, cin);

Serial.print("Writing: a=");
Serial.print(a);
Serial.print(", b=");
Serial.print(b);
Serial.print(", cin=");
Serial.print(cin);
Serial.print(" Expecting: sum=");
Serial.print(sum);
Serial.print(", cout=");
Serial.print(cout);

int measured_sum = digitalRead(PIN_SUM);
int measured_cout = digitalRead(PIN_COUT);

Serial.print(" Got: sum=");
Serial.print(measured_sum);
Serial.print(" cout=");
Serial.print(measured_cout);

Serial.print(" Test:");
if (measured_sum != sum || measured_cout != cout) {
Serial.print(" FAIL");
} else {
Serial.print(" GOOD");
}
Serial.println();
delay(500);
}

void loop() {
Serial.println("Running test");
test(0, 0, 0);
test(0, 0, 1);
test(0, 1, 0);
test(0, 1, 1);
test(1, 0, 0);
test(1, 0, 1);
test(1, 1, 0);
test(1, 1, 1);
}

=Assignment: Debugging ALU design=

Bob had to ship the ALU design to the hardware manufacturer by yesterday. The project manager is angry about missed deadline. Bob still hasn't figured out why the ALU is not working properly. Help Bob by figuring out what's the problem.

If you're on Ubuntu install GHDL and GtkWave, otherwise simply use a school computer:

sudo add-apt-repository ppa:pgavin/ghdl
sudo apt-get update
sudo apt-get install ghdl gtkwave git

Clone the repository

git clone https://github.com/laurivosandi/vhdl-exercise

Use <code>make</code> to compile the components and run the testbench:

cd path/to/vhdl-exercise
make

Expected output of the testbench:

alu_testbench.vhd:77:9:@360ns:(report note): Finished testing addition operation of ALU
alu_testbench.vhd:106:9:@1us:(report note): Finished testing subtraction operation of ALU
alu_testbench.vhd:135:9:@1640ns:(report note): Finished testing NAND operation of ALU
alu_testbench.vhd:166:9:@2280ns:(report note): Finished testing NOR operation of ALU

However there are few bugs in <code>alu.vhd</code>, find the bugs and correct them. If this is your first experience with VHDL, take a look [http://lauri.vosandi.com/hdl/ here].

=Assignment: Publishing your work=

Deadline: 25. November

* Clean up your Git repositories and send the URL of a repository that you've actively worked on (for example the one from Java course) to Lauri, but before check the following:
** The repository should show changes you've made over at least few days.
** The repository has to contain only plaintext files unless there is a really good reason not to (eg. images).
** There has to be authorship information in the files.
** Add <code>.gitignore</code> file to your GitHub repositories to ignore temporary files, see [https://git-scm.com/docs/gitignore Git docs] for more details.
** Add [http://opensource.org/licenses LICENSE] file in the repository directory and commit the changes. LICENSE should answer to some important questions
*** Who is the copyright holder?
*** Under which conditions is redistribution permitted?
** Add nicely formatted README file, see [https://help.github.com/articles/markdown-basics/ Markdown] (online editor [http://dillinger.io here]) and [http://sphinx-doc.org/rest.html reStructuredText] for more details. README should answer to several silly questions:
*** What is the repository about?
*** Who made it?
*** How can the author be contacted? E-mail address, IRC chat channel on Freenode, Skype username?
*** How can the code be used? What hardware is necessary? How should the user wire the circuit to make it work? Add images if necessary.
*** What is the policy for including changes from third party developers?
* There will be more details here

=Extra points=

Here you can claim extra credit points for various tasks, this is mostly to improve the quality of wiki.itcollege.ee.
Once you have taken care of the task insert your name in the end of the line with corresponding date.

* Expand [[Getting started with Ubuntu#Installing in VirtualBox]] section with highlighted screenshots of VirtualBox. Points: 1p
* Create [[Claiming GitHub Student Developer Pack]] with screenshots how to add @itcollege.ee e-mail to your GitHub profile and claim [https://education.github.com/pack Student Developer Pack] Points: 2p

Exam help

2016-01-13T11:44:25Z

Smets: /* What are the major steps of compilation? */

==Computer hardware==

=== Different buses and their uses===
In computer architecture, a bus is a communication system that transfers data between components inside a computer, or between computers. This expression covers all related hardware components (wire, optical fiber, etc.) and software, including communication protocols.

The internal bus, also known as internal data bus, memory bus, system bus or Front-Side-Bus, connects all the internal components of a computer, such as CPU and memory, to the motherboard. Internal data buses are also referred to as a local bus, because they are intended to connect to local devices. This bus is typically rather quick and is independent of the rest of the computer operations.

The external bus, or expansion bus, is made up of the electronic pathways that connect the different external devices, such as printer etc., to the computer.

'''Types and uses:'''
;USB
:Universal Serial Bus. Designed for: input devices, digital cameras, printers, media players...

;Serial ATA
:Used by internal storage devices (hard disk). They replace the old ATA connectors.

;PCI
:Peripheral Component Interconnect, is a local computer bus for attaching hardware devices in a computer. Attached devices can take either the form of an integrated circuit fitted onto the motherboard itself or an expansion card that fits into a slot. Typical PCI cards used in PCs include: network cards, sound cards, modems, extra ports such as USB or serial, TV tuner cards and disk controllers.

;PCI Express
:Peripheral Component Interconnect Express (also called PCIe), is a high-speed serial computer expansion bus standard designed to replace the older PCI, PCI-X, and AGP bus standards. PCIe has numerous improvements over the older standards, including higher maximum system bus throughput, lower I/O pin count and smaller physical footprint, better performance scaling for bus devices, a more detailed error detection and reporting mechanism, and native hot-plug functionality. More recent revisions of the PCIe standard provide hardware support for I/O virtualization.

;Mini PCIe
:It is based on PCI Express technoogy. Main point is its small size and its large variety of connectors makes it used for USB2.0 cards, SIM card, Wifi and Bluetooth cards, 3G and GPS cards.

;ExpressCard
:It is an interface to connect peripheral devices to a computer, usually a laptop computer. ExpressCards can connect a variety of devices to a computer including mobile broadband modems, IEEE 1394 (FireWire) connectors, USB connectors, Ethernet network ports, Serial ATA storage devices, solid-state drives, external enclosures for desktop-size PCI Express graphics cards and other peripheral devices, wireless network interface controllers (NIC), TV tuner cards, Common Access Card (CAC) readers, and sound cards.

===What are the differences between hard disk drive (HDD) and solid state drive (SSD)?===
The traditional spinning hard drive (HDD) is the basic nonvolatile storage on a computer. Hard drives are essentially metal platters with a magnetic coating which stores the data. A read/write head on an arm accesses the data while the platters are spinning in a hard drive enclosure.
An SSD does same the job as an HDD, but instead of a magnetic coating on top of platters, the data is stored on interconnected flash memory chips that retain the data even when there's no power present. HDDs have spinning plates with magnetic coating, while SSDs have no moving parts and instead are using flash memory.

{| class="wikitable"
!Attribute
!SSD (Solid State Drive)
!HDD (Hard Disk Drive)
|-
|Power Draw / Battery Life
|Less power draw, averages 2 – 3 watts, resulting in 30+ minute battery boost
|More power draw, averages 6 – 7 watts and therefore uses more battery
|-
|Cost
|Expensive, roughly $0.10 per gigabyte (based on buying a 1TB drive)
|Only around $0.06 per gigabyte, very cheap (buying a 4TB model)
|-
|Capacity
|Typically not larger than 1TB for notebook size drives; 1TB max for desktops
|Typically around 500GB and 2TB maximum for notebook size drives; 6TB max for desktops
|-
|Operating System Boot Time
|Around 10-13 seconds average bootup time
|Around 30-40 seconds average bootup time
|-
|Noise
|There are no moving parts and as such no sound
|Audible clicks and spinning can be heard
|-
|Vibration
|No vibration as there are no moving parts
|The spinning of the platters can sometimes result in vibration
|-
|Heat Produced
|Lower power draw and no moving parts so little heat is produced
|HDD doesn’t produce much heat, but it will have a measurable amount more heat than an SSD due to moving parts and higher power draw
|-
|Failure Rate
|Mean time between failure rate of 2.0 million hours
|Mean time between failure rate of 1.5 million hours
|-
|File Copy / Write Speed
|Generally above 200 MB/s and up to 550 MB/s for cutting edge drives
|The range can be anywhere from 50 – 120MB / s
|-
|Encryption
|Full Disk Encryption (FDE) Supported on some models
|Full Disk Encryption (FDE) Supported on some models
|-
|File Opening Speed
|Up to 30% faster than HDD
|Slower than SSD
|-
|Magnetism Affected?
|An SSD is safe from any effects of magnetism
|Magnets can erase data
|}

===What is the purpose of Flash Translation Layer in terms of solid state drives?===
Flash drives have limited lifespan due to write cycles (or rather program-erase (PE) cycles) and to exhaust the drive equally, FTL layer is utilised.

Although presenting an array of Logical Block Addresses (LBA) makes sense for HDDs as their sectors can be overwritten, it is not fully suited to the way flash memory works. For this reason, an additional component is required to hide the inner characteristics of NAND flash memory and expose only an array of LBAs to the host. This component is called the Flash Translation Layer (FTL), and resides in the SSD controller. The FTL is critical and has three main purposes: logical block mapping, wear leveling and garbage collection.

The logical block mapping translates logical block addresses (LBAs) from the host space into physical block addresses (PBAs) in the physical NAND-flash memory space. This mapping takes the form of a table, which for any LBA gives the corresponding PBA.

Wear leveling (also written as wear levelling) is a technique[1] for prolonging the service life of some kinds of erasable computer storage media, such as flash memory (used in solid-state drives (SSDs) and USB flash drives).

The garbage collection process in the SSD controller ensures that “stale” pages are erased and restored into a “free” state so that the incoming write commands can be processed. If the data in a page has to be updated, the new version is written to a free page, and the page containing the previous version is marked as stale. When blocks contain stale pages, they need to be erased before they can be written to.

===What are difference between volatile/non-volatile, RAM, ROM, EEPROM and where are they used?===

Volatile = does not hold data after power off.
Non-volatile = holds data even after power off.

Random Access Memory or RAM is a form of data storage that can be accessed randomly at any time, in any order and from any physical location, allowing quick access and manipulation. RAM allows the computer to read data quickly to run applications. It allows reading and writing. It is volatile.

Read-only memory or ROM is also a form of data storage that can not be easily altered or reprogrammed. Stores instuctions that are not nescesary for re-booting up to make the computer operate when it is switched off. They are hardwired. ROM stores the program required to initially boot the computer. It only allows reading. It is non-volatile.

EEPROM (electrically erasable programmable read-only memory) is user-modifiable read-only memory (ROM) that can be erased and reprogrammed. Unlike EPROM chips, EEPROMs do not need to be removed from the computer to be modified. However, an EEPROM chip has to be erased and reprogrammed in its entirety, not selectively. It also has a limited life - that is, the number of times it can be reprogrammed is limited to tens or hundreds of thousands of times. BIOS of PCs are usually written to EEPROM.

===What is data retention?===
It is how long a device can hold data before it becomes unreadable. SSD specifications show a data retention of at least one year for personal devices.

Data retention is also the time a company must (or can) retain informations/logs about its users/customers/suppliers by law.

===What are difference between asynchronous/synchronous, dynamic/static RAM and where are they used?===
The two main forms of modern RAM are static RAM (SRAM) and dynamic RAM (DRAM). In SRAM, a bit of data is stored using the state of a six transistor memory cell. This form of RAM is more expensive to produce, but is generally faster and requires less power than DRAM and, in modern computers, is often used as cache memory for the CPU. DRAM stores a bit of data using a transistor and capacitor pair, which together comprise a DRAM memory cell. The capacitor holds a high or low charge (1 or 0, respectively), and the transistor acts as a switch that lets the control circuitry on the chip read the capacitor's state of charge or change it. As this form of memory is less expensive to produce than static RAM, it is the predominant form of computer memory used in modern computers.
Dynamic RAM is used to create larger RAM space system, where Static RAM create speed- sensitive cache.

Asynchronous refers to the fact that the memory is not synchronized to the system clock. A memory access is begun, and a certain period of time later the memory value appears on the bus. The signals are not coordinated with the system clock at all. Asynchronous memory works fine in lower-speed memory bus systems but is not nearly as suitable for use in high-speed (>66 MHz) memory systems.
A newer type of DRAM, called "synchronous DRAM" or "SDRAM", is synchronized to the system clock; all signals are tied to the clock so timing is much tighter and better controlled. This type of memory is much faster than asynchronous DRAM and can be used to improve the performance of the system. It is more suitable to the higher-speed memory systems of the newest PCs.

===What is [https://compsci2014.wikispaces.com/2.1.3+Explain+the+use+of+cache+memory cache]? What is cache coherence?===

Cache memory is used to reduce the average memory access times. This is done by storing the data that is frequently accessed in main memory addresses therefore allowing the CPU to access the data faster. This is due to the fact that cache memory can be read a lot faster than main memory.

[[File:Cache_Coherency_Generic.png|100px|left]]
Cache coherence is the consistency of shared resource data that ends up stored in multiple local caches. When clients in a system maintain caches of a common memory resource, problems may arise with inconsistent data, which is particularly the case with CPUs in a multiprocessing system.

<br clear=all>
===What are differences between resistive and capacitive touchscreen?===
Resistive touchscreen needs pressure to work by connecting to sheets of plastic and thus conducting electricity. Capacitive touchscreen works by conducting electricity from user's finger.

Resistive touchscreens rely on the pressure of your fingertip—or any other object—to register input. They consist of two flexible layers with an air gap in-between. In order for the touchscreen to register input, you must press on the top layer using a small amount of pressure, in order to depress the top layer enough to make contact with the bottom layer. The touchscreen will then register the precise location of the touch. You can use anything you want on a resistive touchscreen to make the touch interface work; a gloved finger, a wooden rod, a fingernail – anything that creates enough pressure on the point of impact will activate the mechanism and the touch will be registered.

Capacitive touchscreens instead sense conductivity to register input—usually from the skin on your fingertip. Because you don’t need to apply pressure, capacitive touchscreens are more responsive than resistive touchscreens. However, because they work by sensing conductivity, capacitive touchscreens can only be used with objects that have conductive properties, which includes your fingertip (which is most ideal), and special styluses designed with a conductive tip. This is the reason you cannot use a capacitive screen while wearing gloves – the gloves are not conductive, and the touch does not cause any change in the electrostatic field.

[http://www.alphr.com/realworld/357325/capacitive-or-resistive-whats-the-best-type-of-touchscreen In-depth comparison of two]

===Explain how [http://www.bidouille.org/hack/mousecam computer mouse] works?===
An optical computer mouse uses a light source, typically an LED, and a light detector, such as an array of photodiodes, to detect movement relative to a surface.
Modern surface-independent optical mice work by using an optoelectronic sensor (essentially, a tiny low-resolution video camera) to take successive images of the surface on which the mouse operates.
The technology underlying the modern optical computer mouse is known as digital image correlation.
To understand how optical mice work, imagine two photographs of the same object except slightly offset from each other. Place both photographs on a light table to make them transparent, and slide one across the other until their images line up. The amount that the edges of one photograph overhang the other represents the offset between the images, and in the case of an optical computer mouse the distance it has moved.
Optical mice capture one thousand successive images or more per second. Depending on how fast the mouse is moving, each image will be offset from the previous one by a fraction of a pixel or as many as several pixels. Optical mice mathematically process these images using cross correlation to calculate how much each successive image is offset from the previous one.
[http://www.topdesignmag.com/mouse-history-in-photos/ History of computer mouse].

===Explain how [http://www.daskeyboard.com/blog/typing-through-time-the-history-of-the-keyboard/ computer keyboard] works?===
A keyboard is a lot like a miniature computer. It has its own processor and circuitry that carries information to and from that processor. A large part of this circuitry makes up the key matrix.
The key matrix is a grid of circuits underneath the keys. In all keyboards, each circuit is broken at a point below each key. When you press a key, it presses a switch, completing the circuit and allowing a tiny amount of current to flow through. The mechanical action of the switch causes some vibration, called bounce, which the processor filters out. If you press and hold a key, the processor recognizes it as the equivalent of pressing a key repeatedly.
When the processor finds a circuit that is closed, it compares the location of that circuit on the key matrix to the character map in its read-only memory (ROM). A character map is basically a comparison chart or lookup table. It tells the processor the position of each key in the matrix and what each keystroke or combination of keystrokes represents. For example, the character map lets the processor know that pressing the a key by itself corresponds to a small letter "a," but the Shift and a keys pressed together correspond to a capital "A."

[http://computer.howstuffworks.com/keyboard.htm HowStuffworks article]

[http://www.explainthatstuff.com/computerkeyboards.html Explain that Stuff article]

[http://www.daskeyboard.com/blog/typing-through-time-the-history-of-the-keyboard/ Keyboard History]

===Explain how [https://en.wikipedia.org/wiki/Cathode_ray_tube cathode ray tube] (CRT) based screen technology works and name pros/cons.===

The cathode ray tube (CRT) is a vacuum tube containing one or more electron guns, and a phosphorescent screen used to, It has a means to accelerate and deflect the electron beam(s) onto the screen to create the images. The images may represent electrical waveforms (oscilloscope), pictures (television, computer monitor), radar targets or others. CRTs have also been used as memory devices, in which case the visible light emitted from the fluorescent material (if any) is not intended to have significant meaning to a visual observer (though the visible pattern on the tube face may cryptically represent the stored data).

The CRT uses an evacuated glass envelope which is large, deep (i.e. long from front screen face to rear end), fairly heavy, and relatively fragile. As a matter of safety, the face is typically made of thick lead glass so as to be highly shatter-resistant and to block most X-ray emissions, particularly if the CRT is used in a consumer product.

Cons: CRTs, despite recent advances, have remained relatively heavy and bulky and take up a lot of space in comparison to other display technologies. CRT screens have much deeper cabinets compared to flat panels and rear-projection displays for a given screen size, and so it becomes impractical to have CRTs larger than 40 inches (102 cm). The CRT disadvantages became especially significant in light of rapid technological advancements in LCD and plasma flat-panels which allow them to easily surpass 40 inches (102 cm) as well as being thin and wall-mountable, two key features that were increasingly being demanded by consumers.

Pros: CRTs are still popular in the printing and broadcasting industries as well as in the professional video, photography, and graphics fields due to their greater color fidelity, contrast, and better viewing from off-axis (wider viewing angle). CRTs also still find adherents in vintage video gaming because of their higher resolution per initial cost, lowest possible input lag, fast response time, and multiple native resolutions such as 576p.

[https://www.youtube.com/watch?v=2czqYV3T_Kc Slow motion video]

===Explain how [https://en.wikipedia.org/wiki/Liquid-crystal_display liquid crystal displays] (LCD) work and name pros/cons.===

A liquid-crystal display (LCD) is a flat-panel display or other electronic visual display that uses the light-modulating properties of liquid crystals. Liquid crystals do not emit light directly.

LCDs are available to display arbitrary images (as in a general-purpose computer display) or fixed images with low information content, which can be displayed or hidden, such as preset words, digits, and 7-segment displays as in a digital clock. They use the same basic technology, except that arbitrary images are made up of a large number of small pixels, while other displays have larger elements. LCDs are used in a wide range of applications including computer monitors, televisions, instrument panels, aircraft cockpit displays, and signage.

One feature of liquid crystals is that they're affected by electric current. A particular sort of nematic (have a definite order or pattern) liquid crystal, called twisted nematics (TN), is naturally twisted. Applying an electric current to these liquid crystals will untwist them to varying degrees, depending on the current's voltage. LCDs use these liquid crystals because they react predictably to electric current in such a way as to control light passage.

To create an LCD, you take two pieces of polarized glass. You then add a coating of nematic liquid crystals to one of the filters. The first layer of molecules will align with the filter's orientation. Then add the second piece of glass with the polarizing film at a right angle to the first piece. Each successive layer of TN molecules will gradually twist until the uppermost layer is at a 90-degree angle to the bottom, matching the polarized glass filters.

As light strikes the first filter, it is polarized. The molecules in each layer then guide the light they receive to the next layer. As the light passes through the liquid crystal layers, the molecules also change the light's plane of vibration to match their own angle. When the light reaches the far side of the liquid crystal substance, it vibrates at the same angle as the final layer of molecules. If the final layer is matched up with the second polarized glass filter, then the light will pass through.

If we apply an electric charge to liquid crystal molecules, they untwist. When they straighten out, they change the angle of the light passing through them so that it no longer matches the angle of the top polarizing filter. Consequently, no light can pass through that area of the LCD, which makes that area darker than the surrounding areas.

Pros: They are available in a wider range of screen sizes than CRT and plasma displays, and since they do not use phosphors, they do not suffer image burn-in. The LCD screen is more energy-efficient and can be disposed of more safely than a CRT can.
Cons: LCDs are, however, susceptible to image persistence.

[https://www.youtube.com/watch?v=nCHgmCxGEzY Slow motion video]

===Name screen technologies making use of thin film transistor (TFT) technology?===

The best known application of thin-film transistors is in TFT LCDs (active-matrix), an implementation of LCD technology. Transistors are embedded within the panel itself, reducing crosstalk between pixels and improving image stability.

As of 2008, many color LCD TVs and monitors use this technology. TFT panels are frequently used in digital radiography applications (medical).

AMOLED (active-matrix organic light-emitting diode) screens also contain a TFT layer (in best smartphones).

[https://en.wikipedia.org/wiki/Thin-film_transistor Wikipedia article]

===Name uses for light polarization filters?===
A polarizer or polariser is an optical filter that passes light of a specific polarization and blocks waves of other polarizations. It can convert a beam of light of undefined or mixed polarization into a beam with well-defined polarization, polarized light. Polarizers are used in many optical techniques and instruments, and polarizing filters find applications in photography, liquid crystal display technology and 3D watching. Polarizers can also be made for other types of electromagnetic waves besides light, such as radio waves, microwaves, and X-rays.

[https://en.wikipedia.org/wiki/Polarizing_filter_%28photography%29 Polarizer photo] [https://en.wikipedia.org/wiki/Polarized_3D_system Polarizer 3D]

===What are the benefits of [https://en.wikipedia.org/wiki/Twisted_pair twisted pair cabling] and [https://en.wikipedia.org/wiki/Differential_signaling differential signalling]?===
'''Twisted pair''' cabling is a type of wiring in which two conductors of a single circuit are twisted together for the purposes of canceling out electromagnetic interference (EMI) from external sources; for instance, electromagnetic radiation from unshielded twisted pair (UTP) cables, and crosstalk between neighboring pairs.

'''Differential signaling''' is a method for electrically transmitting information using two complementary signals. The technique sends the same electrical signal as a differential pair of signals, each in its own conductor. The pair of conductors can be wires (typically twisted together) or traces on a circuit board. The receiving circuit responds to the electrical difference between the two signals, rather than the difference between a single wire and ground. Since the receiving circuit only detects the difference between the wires, the technique resists electromagnetic noise compared to one conductor with an un-paired reference (ground). The technique works for both analog signaling and digital signaling.

===[https://en.wikipedia.org/wiki/Active_matrix Active matrix] vs [https://en.wikipedia.org/wiki/Passive_matrix_addressing passive matrix] in display technology===
Active-matrix display : Active-matrix LCDs depend on thin film transistors (TFT). Basically, TFTs are tiny switching transistors and capacitors. They are arranged in a matrix on a glass substrate. To address a particular pixel, the proper row is switched on, and then a charge is sent down the correct column. Since all of the other rows that the column intersects are turned off, only the capacitor at the designated pixel receives a charge. The capacitor is able to hold the charge until the next refresh cycle. And if we carefully control the amount of voltage supplied to a crystal, we can make it untwist only enough to allow some light through. It displays high-quality colour that is viewable from all angles and reduces crosstalk between pixels and improving image stability.

Passive-matrix display : it uses a simple grid to supply the charge to a particular pixel on the display. The rows or columns are connected to integrated circuits that control when a charge is sent down a particular column or row. To turn on a pixel, the integrated circuit sends a charge down the correct column of one substrate and a ground activated on the correct row of the other. The row and column intersect at the designated pixel, and that delivers the voltage to untwist the liquid crystals at that pixel. The simplicity of the passive-matrix system is beautiful, but it has significant drawbacks, notably slow response time and imprecise voltage control. Response time refers to the LCD's ability to refresh the image displayed. The easiest way to observe slow response time in a passive-matrix LCD is to move the mouse pointer quickly from one side of the screen to the other. You will notice a series of "ghosts" following the pointer. Imprecise voltage control hinders the passive matrix's ability to influence only one pixel at a time. When voltage is applied to untwist one pixel, the pixels around it also partially untwist, which makes images appear fuzzy and lacking in contrast.

==Storage abstractions==

===What is a [https://en.wikipedia.org/wiki/Block_%28data_storage%29 block device]?===
In computing (specifically data transmission and data storage), a block, sometimes called a physical record, is a sequence of bytes or bits, usually containing some whole number of records, having a maximum length, a block size.Data thus structured are said to be blocked. The process of putting data into blocks is called blocking. Most file systems are based on a block device, which is a level of abstraction for the hardware responsible for storing and retrieving specified blocks of data

===What is [https://en.wikipedia.org/wiki/Logical_block_addressing logical block addressing] and what are the benefits compared to older [https://en.wikipedia.org/wiki/Cylinder-head-sector cylinder-head-sector addressing] method in terms of harddisks?===
Logical block addressing (LBA) is a common scheme used for specifying the location of blocks of data stored on computer storage devices, generally secondary storage systems such as hard disk drives. LBA is a particularly simple linear addressing scheme; blocks are located by an integer index, with the first block being LBA 0, the second LBA 1, and so on.

Cylinder-head-sector, also known as CHS, is an early method for giving addresses to each physical block of data on a hard disk drive. CHS addressing is the process of identifying individual sectors on a disk by their position in a track, where the track is determined by the head and cylinder numbers.

LBA allows a maximum addressing capacity of 2TB although CHS allows 8GB

===What is a [https://en.wikipedia.org/wiki/Disk_partitioning disk partition]?===
Disk partitioning is the creation of one or more regions on a hard disk or other secondary storage, so that an operating system can manage information in each region separately. Partitioning is typically the first step of preparing a newly manufactured disk, before any files or directories have been created. The disk stores the information about the partitions' locations and sizes in an area known as the partition table that the operating system reads before any other part of the disk. Each partition then appears in the operating system as a distinct "logical" disk that uses part of the actual disk.

===What is a [https://en.wikipedia.org/wiki/File_system file system]?===
In computing, a file system (or filesystem) is used to control how data is stored and retrieved. Without a file system, information placed in a storage area would be one large body of data with no way to tell where one piece of information stops and the next begins. By separating the data into individual pieces, and giving each piece a name, the information is easily separated and identified. Taking its name from the way paper-based information systems are named, each group of data is called a "file". The structure and logic rules used to manage the groups of information and their names is called a "file system".

===What is [https://en.wikipedia.org/wiki/Journaling_file_system#Write_hazards journaling] in terms of filesystems and what are the benefits? Name some journaled file systems in use nowadays.===
A journaling file system is a file system that keeps track of changes not yet committed to the file system's main part by recording the intentions of such changes in a data structure known as a "journal", which is usually a circular log. In the event of a system crash or power failure, such file systems can be brought back online quicker with lower likelihood of becoming corrupted.

Depending on the actual implementation, a journaling file system may only keep track of stored metadata, resulting in improved performance at the expense of increased possibility for data corruption. Alternatively, a journaling file system may track both stored data and related metadata, while some implementations allow selectable behavior in this regard.

Modern journaling: HFS+, NTFS, ext4, Btrfs, ZFS

==Bootloaders, kernels==

===What is the role of BIOS/UEFI in x86-based machines?===
BIOS (Basic Input/Output System) performs during boot up process of a computer and prepares it for the OS and its' programs.

UEFI (Unified Extensible Firmware Interface) is a replacement for BIOS. It offers several advantages over previous firmware interface, like:
* Ability to boot from large disks (over 2 TB) with a GUID Partition Table (GPT)
* CPU-independent architecture
* CPU-independent drivers
* Flexible pre-OS environment, including network capability
* Modular design

===Explain step by step how operating system is booted up, see slides for flowchart.===
[[File:ChromeOSFirmwareBootandRecoveryPUBLISHED.png#filelinks]]

1. The first thing a computer has to do when it is turned on is start up a special program called an operating system. That process is called booting. The instructions for booting are built into BIOS (Basic input/output system).

2. The BIOS will tell your computer to look into the boot disk (usually the lowest-numbered hard disk) for a boot loader and the boot loader will be pulled into memory and will be started.

3. The boot loader's job is to start the real operating system and it does it by looking for a kernel, loading it into memory and starting it.

5. Once the kernel starts, it has to look around to find the rest of the hardware and get ready to run programs ( It does this by poking not at ordinary memory locations but rather at I/O ports — special bus addresses that are likely to have device controller cards listening at them for commands). The kernel doesn't poke at random; it has a lot of built-in knowledge about what it's likely to find where, and how controllers will respond if they're present. This process is called autoprobing.

6. After the kernel is up and running, it's the end of first stage. After the first stage, the kernel hands control to a special program called "init" which spawns housekeeping processes. The init's process's first task is to look that your hard disks are okay

7. Init's next step is to start several daemons. A daemon is a program like a print spooler, a mail listener or a WWW server that lurks in the background, waiting for things to do. These special programs often have to coordinate several requests that could conflict. They are daemons because it's often easier to write one program that runs constantly and knows about all requests than it would be to try to make sure that a flock of copies (each processing one request and all running at the same time) don't step on each other.

8. The next step is to prepare for users. Init starts a copy of a program called getty to watch your screen and keyboard (and maybe more copies to watch dial-in serial ports).

9. The next step is to start up various daemons that support networking and other services. The most important of these is your X server. X is a daemon that manages your display, keyboard, and mouse. Its main job is to produce the color pixel graphics you normally see on your screen.

10. When the X server comes up, during the last part of your machine's boot process, it effectively takes over the hardware from whatever virtual console was previously in control. That's when you'll see a graphical login screen, produced for you by a program called a display manager.

===BIOS===
* Basic input and output system
* Located at memory location 0xFFFF0
* Boot firmware designed to be run at startup
* POST- power on self test
* Run-time service
initial configuration
selects which device to boot from
* Alternatively, Extensible Firmware Interface (EFI)

===Describe the functionality provided by general purpose operating system.===
An operating system (OS) is system software that manages computer hardware and software resources and provides common services for computer programs. The operating system is a component of the system software in a computer system. Application programs usually require an operating system to function.

Time-sharing operating systems schedule tasks for efficient use of the system and may also include accounting software for cost allocation of processor time, mass storage, printing, and other resources.

For hardware functions such as input and output and memory allocation, the operating system acts as an intermediary between programs and the computer hardware, although the application code is usually executed directly by the hardware and frequently makes system calls to an OS function or is interrupted by it. Operating systems are found on many devices that contain a computer—from cellular phones and video game consoles to web servers and supercomputers.

See architecture of [https://en.wikipedia.org/wiki/Architecture_of_Windows_NT Windows NT], [http://www.elinux.org/Android_Architecture Android], [https://en.wikipedia.org/wiki/Architecture_of_OS_X OS X].

===What are the main differences between [https://en.wikipedia.org/wiki/Real_mode real mode] and [https://en.wikipedia.org/wiki/Protected_mode protected mode] of x86-based processor?===

Protected mode differed from the original mode of the 8086, which was later dubbed “real mode”, in that areas of memory could be physically isolated by the processor itself to prevent illegal writes to other programs running in memory at the same time. Prior to protected mode, multiple programs could be running in memory at the same time, but any program could access any area of memory and, therefore, if malicious or errant, for example, could take down the entire system. The 80286 introduced the protected mode to isolate that possibility by allowing the operating system (OS) to dictate where each program should run.

===What happens during context switch?===

During a context switch, the kernel will save the context of the old process in its PCB and then load the saved context of the new process scheduled to run.

===What is the purpose of [https://en.wikipedia.org/wiki/Virtual_memory paged virtual memory]?===
Virtual memory is a memory management technique that is implemented using both hardware and software. It maps memory addresses used by a program, called virtual addresses, into physical addresses in computer memory. Main storage as seen by a process or task appears as a contiguous address space or collection of contiguous segments. The operating system manages virtual address spaces and the assignment of real memory to virtual memory. Address translation hardware in the CPU, often referred to as a memory management unit or MMU, automatically translates virtual addresses to physical addresses. Software within the operating system may extend these capabilities to provide a virtual address space that can exceed the capacity of real memory and thus reference more memory than is physically present in the computer.

The primary benefits of virtual memory include freeing applications from having to manage a shared memory space, increased security due to memory isolation, and being able to conceptually use more memory than might be physically available, using the technique of paging.

'''Paged virtual memory''': nearly all implementations of virtual memory divide a virtual address space into pages, blocks of contiguous virtual memory addresses. Pages on contemporary[NB 2] systems are usually at least 4 kilobytes in size; systems with large virtual address ranges or amounts of real memory generally use larger page sizes.

use <code>cat /proc/meminfo</code> to see the virtual memory.

==Libraries, frameworks==

'''OS provides libraries'''
*Render fonts: libfreetype
*Render user interface: GTK, Qt, Cocoa, MFC
*Playback MP3-s: libmad, Gstreamer,
*Encrypt connections: OpenSSL, LibreSSL, etc.
*Database functionality: SQLite
*Web browsing: WebKit
*3D graphics: OpenGL, DirectX
*Runtime environments: Java VM, .NET

'''OS provides services'''
*IPC (Inter-process communication) aka send messages between apps
*Window management
*Cache geolocation information
*Manage phonecalls
*Network management
*Framework ≃ Bunch of libraries + some services

==Programming languages==

===What are the major steps of compilation?===
1. '''Lexer'''

The first phase of scanner works as a text scanner. This phase scans the source code as a stream of characters and converts it into meaningful lexemes. Lexical analyser represents these lexemes in the form of tokens as: <token-name, attribute-value>

2. '''Parser'''

The next phase is called the syntax analysis or parsing. It takes the token produced by lexical analysis as input and generates a parse tree (or syntax tree). In this phase, token arrangements are checked against the source code grammar, i.e. the parser checks if the expression made by the tokens is syntactically correct.

3. '''Type checker'''

Semantic analysis checks whether the parse tree constructed follows the rules of language. For example, assignment of values is between compatible data types, and adding string to an integer. Also, the semantic analyser keeps track of identifiers, their types and expressions; whether identifiers are declared before use or not etc. The semantic analyser produces an annotated syntax tree as an output and an intermediate code is produced.

4. '''Optimizer'''

The next phase does code optimization of the intermediate code. Optimization can be assumed as something that removes unnecessary code lines, and arranges the sequence of statements in order to speed up the program execution without wasting resources (CPU, memory).

5. '''Code generator'''

In this phase, the code generator takes the optimized representation of the intermediate code and maps it to the target machine language. The code generator translates the intermediate code into a sequence of (generally) re-locatable machine code. Sequence of instructions of machine code performs the task as the intermediate code would do.

nmap 192.168.12.1-254 -p22,80

===What are the differences between [https://en.wikipedia.org/wiki/Interpreted_language interpreted], [https://en.wikipedia.org/wiki/Just-in-time_compilation JIT-compilation] and [https://en.wikipedia.org/wiki/Compiler traditional compiling]?===

'''Interpreted language'''

An interpreted language is a programming language for which most of its implementations execute instructions directly, without previously compiling a program into machine-language instructions. The interpreter executes the program directly, translating each statement into a sequence of one or more subroutines already compiled into machine code. Example: JavaScript

'''Just-in-time compilation'''

In computing, just-in-time (JIT) compilation, also known as dynamic translation, is compilation done during execution of a program – at run time – rather than prior to execution. Most often this consists of translation to machine code, which is then executed directly, but can also refer to translation to another format.

'''Compiler'''

A compiler is a computer program (or a set of programs) that transforms source code written in a programming language (the source language) into another computer language (the target language), with the latter often having a binary form known as object code. The most common reason for converting source code is to create an executable program.

===What is [https://en.wikipedia.org/wiki/Control_flow control flow]? Loops? Conditional statements?===
Flow control
In computer science, control flow (or alternatively, flow of control) is the order in which individual statements, instructions or function calls of an imperative program are executed or evaluated. The emphasis on explicit control flow distinguishes an imperative programming language from a declarative programming language.
Within an imperative programming language, a control flow statement is a statement whose execution results in a choice being made as to which of two or more paths should be followed. For non-strict functional languages, functions and language constructs exist to achieve the same result, but they are not necessarily called control flow statements.

The kinds of control flow statements supported by different languages vary, but can be categorized by their effect:

* continuation at a different statement (unconditional branch or jump),
* executing a set of statements only if some condition is met (choice - i.e., conditional branch),
* executing a set of statements zero or more times, until some condition is met (i.e., loop - the same as conditional branch),
* executing a set of distant statements, after which the flow of control usually returns (subroutines, coroutines, and continuations),
* stopping the program, preventing any further execution (unconditional halt).

Count-controlled loops

Most programming languages have constructions for repeating a loop a certain number of times. Note that if N is less than 1 in these examples then the language may specify that the body is skipped completely, or that the body is executed just once with N = 1. In most cases counting can go downwards instead of upwards and step sizes other than 1 can be used.

FOR I = 1 TO N | for I := 1 to N do begin
xxx | xxx
NEXT I | end;
------------------------------------------------------------
DO I = 1,N | for ( I=1; I<=N; ++I ) {
xxx | xxx
END DO | }

In many programming languages, only integers can be reliably used in a count-controlled loop. Floating-point numbers are represented imprecisely due to hardware constraints, so a loop such as

==Data encoding==

===What is bit? Nibble? Byte? Word?===
A bit is the basic unit of information in computing and digital communications. A bit can have only one of two values, and may therefore be physically implemented with a two-state device. These values are most commonly represented as either a 0 or 1. The two values can also be interpreted as logical values (true/false, yes/no), algebraic signs (+/−), activation states (on/off), or any other two-valued attribute.

Nibble is half of an octet. A nibble has sixteen possible values.

Byte is a unit of eight bits. Comes from the number of bits used to encode a single character of text in a computer. The term byte initially meant 'the smallest addressable unit of memory'. In the past, 5-, 6-, 7-, 8-, and 9-bit bytes have all been used. The term byte was usually not used at all in connection with bit- and word-addressed machines. The term octet always refers to an 8-bit quantity. It is mostly used in the field of computer networking, where computers with different byte widths might have to communicate. In modern usage byte almost invariably means eight bits, since all other sizes have fallen into disuse; thus byte has come to be synonymous with octet.

The term 'word' is used for a small group of bits which are handled simultaneously by processors of a particular architecture. The size of a word is thus CPU-specific. The size of a word is reflected in many aspects of a computer's structure and operation; the majority of the registers in a processor are usually word sized and the largest piece of data that can be transferred to and from the working memory in a single operation is a word in many (not all) architectures. Modern general purpose computers usually use 32 or 64 bits.

===Write 9375 in binary, hexadecimal?===
'''Binary''' or base two counting system starts from right with 0 and continues left with each step being to the power of 2.

{| class="wikitable" style="text-align: right;"
| 2^14
| 2^13
| 2^12
| 2^11
| 2^10
| 2^9
| 2^8
| 2^7
| 2^6
| 2^5
| 2^4
| 2^3
| 2^2
| 2^1
| 2^0
|-
| 16384
| 8192
| 4096
| 2048
| 1024
| 512
| 256
| 128
| 64
| 32
| 16
| 8
| 4
| 2
| 1
|-
| 0
| 1
| 0
| 0
| 1
| 0
| 0
| 1
| 0
| 0
| 1
| 1
| 1
| 1
| 1
|}

To find out the decimal number (9375) in binary, look if it contains the number equal or smaller. 8192 is smaller than 9375, mark down 1. 9375-8192=1183 contains 1024, mark 1, etc. Number 9375 base ten is 0x10010010011111 in binary, where the '0b' represents base two. From binary to decimal conversion works the other way around. If perplexed, [https://www.khanacademy.org/math/pre-algebra/applying-math-reasoning-topic/alternate-number-bases/v/decimal-to-binary see the explanatory video on Khan academy].

'''Hexadecimal''' or base 16 system goes from 0 until 9, then starts with A (10 base 10) until F (15 base 10).

{| class="wikitable" style="text-align: right;"
| 0
| 1
|2
|3
|4
|5
|6
|7
|8
|9
|10
|11
|12
|13
|14
|15
|-
|0
|1
|2
|3
|4
|5
|6
|7
|8
|9
|A
|B
|C
|D
|E
|F
|}

Conversion from base two to hex is similar to decimal to base two conversion. First, we figure out the multiples of 16:

{| class="wikitable" style="text-align: right;"
|16^0
|16^1
|16^2
|16^3
|16^4
|-
|1
|16
|256
|4096
|65 536
|-
|F
|9
|4
|2
|<-
|}

9375 has two multiples of 4096 (9375 - '''2'''*4096 = 9375 - 8192 = 1183), 1183 has '''4''' multiples of 256 (1183 - '''4'''*256 = 159), 159 has 159 - '''9'''*16 = 15 (15 in decimal is '''F''' in hex) and we come to 249F. As with base 2, you can convert this way from hex to decimal. If still don't get it, watch a [https://www.khanacademy.org/math/pre-algebra/applying-math-reasoning-topic/alternate-number-bases/v/decimal-to-hexadecimal video on Khan academy].

===Write 0xDEADBEEF in decimal?===
Following the table above we calculate, 13x16^8 + 14x16^7 + 10x16^6 + 13x16^5 + 11x16^4 + 14x16^3 + 14x16^2 + 15x16^1 = A BIG NUMBER!

===What is [https://en.wikipedia.org/wiki/Quantization_%28signal_processing%29 quantization] in terms of signal processing?===
Quantization, in mathematics and digital signal processing, is the process of mapping a large set of input values to a (countable) smaller set. Rounding and truncation are typical examples of quantization processes. Quantization is involved to some degree in nearly all digital signal processing, as the process of representing a signal in digital form ordinarily involves rounding. Quantization also forms the core of essentially all lossy compression algorithms. The difference between an input value and its quantized value (such as round-off error) is referred to as quantization error. A device or algorithmic function that performs quantization is called a quantizer. An analog-to-digital converter is an example of a quantizer.

===How are [https://en.wikipedia.org/wiki/Integer_%28computer_science%29 integers] stored in binary? What integer range can be described using n bits? How many bits are required to describe integer range from n .. m.===
The value of an item with an integral type is the mathematical integer that it corresponds to. Integral types may be unsigned (capable of representing only non-negative integers) or signed (capable of representing negative integers as well).

The most common representation of a positive integer is a string of bits, using the binary numeral system. The order of the memory bytes storing the bits varies; see endianness. The width or precision of an integral type is the number of bits in its representation. An integral type with n bits can encode 2n numbers.

There are four well-known ways to represent signed numbers in a binary computing system. The most common is two's complement, which allows a signed integral type with n bits to represent numbers from −2(n−1) through 2(n−1)−1.

===How are [https://en.wikipedia.org/wiki/Single-precision_floating-point_format single precision] and [https://en.wikipedia.org/wiki/Double-precision_floating-point_format double precision] floating point numbers stored in binary according to [https://en.wikipedia.org/wiki/IEEE_floating_point IEEE754 standard]?===
[http://lauri.vosandi.com/hdl/arithmetic/floating-point-representation.html Floating-point multiplication]

===What is the difference between CMYK and RGB color models? How are YUV, HSV and HSL colorspaces related to RGB? What are sRGB and YCbCr and where are they used?===

'''CMYK Color Mode'''
[[File:SubtractiveColor.svg.png|right|100px|]]
If printers are using a digital printing method, they would print color on paper using CMYK colors. This is a four color mode that utilizes the colors '''cyan''', '''magenta''', '''yellow''' and '''black''' in various amounts to create all of the necessary colors when printing images. It is a subtractive process which, from a white background, adding a unique color means more light is removed, or absorbed, to create new colors. When the first three colors are added together, the result is not pure black, but rather a very dark brown. The K color, or black, is used to completely remove light from the printed picture, which is why the eye perceives the color as black.

<br clear=all>
'''RGB Color Mode'''
[[File:220px-AdditiveColor.svg.png|right|100px|]]
RGB is the color scheme that is associated with electronic displays, such as CRT, LCD monitors, digital cameras and scanners. It is an additive type of color mode that, from a black background, combines the primary colors, red, green and blue, in various degrees to create a variety of different colors. When all three of the colors are combined and displayed to their full extent, the result is a pure white. When all three colors are combined to the lowest degree, or value, the result is black. Software such as photo editing programs use the RGB color mode because it offers the widest range of colors.

<br clear=all>

'''YUV, HSV, HSL'''

The Y'UV model defines a color space in terms of one luma (Y') and two chrominance (UV) components. The Y'UV color model is used in the PAL and SECAM composite color video standards.YUV models human perception of color more closely than the standard RGB model used in computer graphics hardware. Y' stands for the luma component (the brightness) and U and V are the chrominance (color) components.

HSV (hue, saturation, value), is often used by artists because it is often more natural to think about a color in terms of hue and saturation than in terms of additive or subtractive color components. HSL (hue, saturation, lightness/luminance), also known as HSL, HSI (hue, saturation, intensity) or HSD (hue, saturation, darkness), is quite similar to HSV, with "lightness" replacing "brightness". HSV and HSL are a transformation of an RGB colorspace, and its components and colorimetry are relative to the RGB colorspace from which it was derived.

'''sRGB and YCbCr'''

sRGB is pretty much the default color space everywhere you look. This means that most browsers, applications, and devices are designed to work with sRGB, and assume that images are in the sRGB color space. In fact, most browser simply ignore the embedded color space information in images and render them as sRGB images. If you publish your images on the web, you should always save and publish them as sRGB.

YCbCr is one of two primary color spaces used to represent digital component video (the other is RGB). The difference between YCbCr and RGB is that YCbCr represents color as brightness and two color difference signals, while RGB represents color as red, green and blue. In YCbCr, the Y is the brightness (luma), Cb is blue minus luma (B-Y) and Cr is red minus luma (R-Y). MPEG compression, which is used in DVDs, digital TV and Video CDs, is coded in YCbCr.

===How is data encoded on audio CD-s? What is the [http://lauri.vosandi.com/2013/07/audio-codecs.html capacity of an audio CD]?===

There are 2 channels (left and right).
The amplitude of the voltage sound level is encoded with 16 bits per channel (or 2 bytes).
The sampling rate is how often this amplitude is measured: 44.1kHz (44100 times a second).
The CD had a specification to hold 80 minutes of music (4800 seconds).

Capacity of a audio CD in bytes = 2 channels x 2 bytes (16 bites) x 44100 Hz x 4800 seconds = 846720000 bytes => 846 Mbytes

===What is sampling rate? What is bit depth? What is resolution?===
'''SAMPLE RATE:'''
Sample rate is the number of samples of audio carried per second, measured in Hz or kHz (one kHz being 1 000 Hz). For example, 44 100 samples per second can be expressed as either 44 100 Hz, or 44.1 kHz. Bandwidth is the difference between the highest and lowest frequencies carried in an audio stream

'''BIT DEPTH:'''
Bit depth refers to the color information stored in an image. The higher the bit depth of an image, the more colors it can store. The simplest image, a 1 bit image, can only show two colors, black and white

'''RESOLUTION:'''
Resolution is the number of pixels (individual points of color) contained on a display monitor, expressed in terms of the number of pixels on the horizontal axis and the number on the vertical axis. The sharpness of the image on a display depends on the resolution and the size of the monitor.

===What is bitrate?===
Bitrate is the number of bits that are conveyed or processed per unit of time.

The bit rate is quantified using the bits per second unit (symbol: "bit/s"), often in conjunction with an SI prefix such as "kilo" (1 kbit/s = 1000 bit/s), "mega" (1 Mbit/s = 1000 kbit/s), "giga" (1 Gbit/s = 1000 Mbit/s) or "tera" (1 Tbit/s = 1000 Gbit/s).[2] The non-standard abbreviation "bps" is often used to replace the standard symbol "bit/s", so that, for example, "1 Mbps" is used to mean one million bits per second.

One byte per second (1 B/s) corresponds to 8 bit/s.

===What is lossy/lossless compression?===
Lossless and lossy compression are terms that describe whether or not, in the compression of a file, all original data can be recovered when the file is uncompressed. With lossless compression, every single bit of data that was originally in the file remains after the file is uncompressed.

===What is JPEG suitable for? Is JPEG lossy or lossless compression method?===
JPEG is a commonly used method of lossy compression for digital images, particularly for those images produced by digital photography. The degree of compression can be adjusted, allowing a selectable tradeoff between storage size and image quality. JPEG typically achieves 10:1 compression with little perceptible loss in image quality. JPEG compression is used in a number of image file formats. JPEG/Exif is the most common image format used by digital cameras and other photographic image capture devices; along with JPEG/JFIF, it is the most common format for storing and transmitting photographic images on the World Wide Web. These format variations are often not distinguished, and are simply called JPEG.

===What is PNG suitable for? Does PNG support compression?===

Portable Network Graphics is a raster graphics file format that supports lossless data compression. PNG was created as an improved, non-patented replacement for Graphics Interchange Format (GIF), and is the most used lossless image compression format on the Internet.

===How are time domain and frequency domain related in terms of signal processing? What is Fourier transform and where it is applied?===

==Code execution in processor==

===Given ~10 instructions and their explainations, follow the instructions and elaborate after every step what happened in the processor?===

==Microcontrollers==

===What distinguishes microcontroller from microprocessor?===
{| class="wikitable"
|'''MICROPROCESSOR'''
|'''MICRO CONTROLLER'''
|-
|Microprocessor is heart of Computer system.
|Micro Controller is a heart of embedded system.
|-
|It is just a processor. Memory and I/O components have to be connected externally
|Micro controller has external processor along with internal memory and i/O components
|-
|Since memory and I/O has to be connected externally, the circuit becomes large.
|Since memory and I/O are present internally, the circuit is small.
|-
|Cannot be used in compact systems and hence inefficient
|Can be used in compact systems and hence it is an efficient technique
|-
|Cost of the entire system increases
|Cost of the entire system is low
|-
|Due to external components, the entire power consumption is high. Hence it is not suitable to used with devices running on stored power like batteries.
|Since external components are low, total power consumption is less and can be used with devices running on stored power like batteries.
|-
|Most of the microprocessors do not have power saving features.
|Most of the micro controllers have power saving modes like idle mode and power saving mode. This helps to reduce power consumption even further.
|-
|Since memory and I/O components are all external, each instruction will need external operation, hence it is relatively slower.
|Since components are internal, most of the operations are internal instruction, hence speed is fast.
|-
|Microprocessor have less number of registers, hence more operations are memory based.
|Micro controller have more number of registers, hence the programs are easier to write.
|-
|Microprocessors are based on von Neumann model/architecture where program and data are stored in same memory module
|Micro controllers are based on Harvard architecture where program memory and Data memory are separate
|-
|Mainly used in personal computers
|Used mainly in washing machine, MP3 players
|}

===What are the differences between Harvard architecture and von Neumann architecture?===
Difference of von Neumann architecture from Harvard is that von Neumann can do a single operation at a time -- it cannot write while reading an instruction. A property that a computer with Harvard architecture can do.

===What is an interrupt?===
Interrupt is a signal that there is something that requires immediate attention from the processing unit. Processor suspends its current activities, saves its state, deals with the temporary interrupt and returns itself to the previous state.

===What is an timer?===
Timer is a line of code that tracks the passage of time based on the clock oscillator which is built in to the hardware where the software is running.

==Introduction to Boole algebra==

===Simplify A AND A OR B===

===Show addition of X and Y in binary===

Two's Complement Addition

Add the values and discard any carry-out bit.

Examples: using 8-bit two’s complement numbers.

Add −8 to +3
(+3) 0000 0011
+(−8) 1111 1000
-----------------
(−5) 1111 1011

Add −5 to −2
(−2) 1111 1110
+(−5) 1111 1011
-----------------
(−7) 1 1111 1001 : discard carry-out

===Show subtraction of X and Y in binary===

Two's Complement Subtraction

Normally accomplished by negating the subtrahend and adding it to the minuhend. Any carry-out is discarded.

Example: Using 8-bit Two's Complement Numbers (−128 ≤ x ≤ +127)

(+8) 0000 1000 0000 1000
−(+5) 0000 0101 -> Negate -> +1111 1011
----- -----------
(+3) 1 0000 0011 : discard carry-out

===Show multiplication of X and Y in binary===

Multiplication Example 11001012 × 1111012 (10110 × 6110)

1100101 10110
× 111101 × 6110
-------
1100101
+1100101
+1100101
+1100101
+1100101
-------------
?????????????
-------------

Easier to use intermediary results:

1100101 10110
× 111101 × 6110
-------
1100101
+1100101
----------
111111001
+1100101
------------
10100100001
+1100101
-------------
101101110001
+1100101
-------------
1100000010001 = 409610 + 204810 + 1610 + 1 = 616110
-------------

==Hardware description languages==

===What are the uses for hardware description languages?===
In electronics, a hardware description language (HDL) is a specialized computer language used to program the structure, design and operation of electronic circuits, and most commonly, digital logic circuits.

A hardware description language enables a precise, formal description of an electronic circuit that allows for the automated analysis, simulation, and simulated testing of an electronic circuit. It also allows for the compilation of an HDL program into a lower level specification of physical electronic components, such as the set of masks used to create an integrated circuit.

A hardware description language looks much like a programming language such as C; it is a textual description consisting of expressions, statements and control structures. One important difference between most programming languages and HDLs is that HDLs explicitly include the notion of time.

===What is latch?===
A latch is an example of a bistable multivibrator, that is, a device with exactly two stable states. These states are high-output and low-output. A latch has a feedback path, so information can be retained by the device. Therefore latches can be memory devices, and can store one bit of data for as long as the device is powered. As the name suggests, latches are used to "latch onto" information and hold in place. Latches are very similar to flip-flops, but are not synchronous devices, and do not operate on clock edges as flip-flops do.

===What is flip-flop?===
A flip-flop is a device very like a latch in that it is a bistable multivibrator, having two states and a feedback path that allows it to store a bit of information. The difference between a latch and a flip-flop is that a latch is asynchronous, and the outputs can change as soon as the inputs do (or at least after a small propagation delay). A flip-flop, on the other hand, is edge-triggered and only changes state when a control signal goes from high to low or low to high. This distinction is relatively recent and is not formal, with many authorities still referring to flip-flops as latches and vice versa, but it is a helpful distinction to make for the sake of clarity.

There are several different types of flip-flop each with its own uses and peculiarities. The four main types of flip-flop are : SR, JK, D, and T.

===What is mux (multiplexer)?===
A multiplexer (or mux) is a device that selects one of several analog or digital input signals and forwards the selected input into a single line.[1] A multiplexer of 2n inputs has n select lines, which are used to select which input line to send to the output.[2] Multiplexers are mainly used to increase the amount of data that can be sent over the network within a certain amount of time and bandwidth.[1] A multiplexer is also called a data selector.

An electronic multiplexer makes it possible for several signals to share one device or resource, for example one A/D converter or one communication line, instead of having one device per input signal.

===What is register? Register file?===
'''Registers''' are a special, high-speed storage area within the CPU. All data must be represented in a register before it can be processed. For example, if two numbers are to be multiplied, both numbers must be in registers, and the result is also placed in a register. A register may hold a computer instruction , a storage address, or any kind of data (such as a bit sequence or individual characters). A register must be large enough to hold an instruction - for example, in a 32-bit instruction computer, a register must be 32 bits in length. In some computer designs, there are smaller registers - for example, half-registers - for shorter instructions. Depending on the processor design and language rules, registers may be numbered or have arbitrary names.

A '''register file''' is an array of processor registers in a central processing unit (CPU). Modern integrated circuit-based register files are usually implemented by way of fast static RAMs with multiple ports. Such RAMs are distinguished by having dedicated read and write ports, whereas ordinary multiported SRAMs will usually read and write through the same ports.

The instruction set architecture of a CPU will almost always define a set of registers which are used to stage data between memory and the functional units on the chip. In simpler CPUs, these architectural registers correspond one-for-one to the entries in a physical register file within the CPU. More complicated CPUs use register renaming, so that the mapping of which physical entry stores a particular architectural register changes dynamically during execution. The register file is part of the architecture and visible to the programmer, as opposed to the concept of transparent caches.

===What is ALU?===
An arithmetic logic unit (ALU) is a digital electronic circuit that performs arithmetic and bitwise logical operations on integer binary numbers. This is in contrast to a floating-point unit (FPU), which operates on floating point numbers. An ALU is a fundamental building block of many types of computing circuits, including the central processing unit (CPU) of computers, FPUs, and graphics processing units (GPUs). A single CPU, FPU or GPU may contain multiple ALUs.

The inputs to an ALU are the data to be operated on, called operands, and a code indicating the operation to be performed; the ALU's output is the result of the performed operation. In many designs, the ALU also exchanges additional information with a status register, which relates to the result of the current or previous operations.

===What is floating-point unit?===
A floating-point unit (FPU) is a part of a computer system specially designed to carry out operations on floating point numbers. Typical operations are addition, subtraction, multiplication, division, square root, and bitshifting. Some systems (particularly older, microcode-based architectures) can also perform various transcendental functions such as exponential or trigonometric calculations, though in most modern processors these are done with software library routines.

In general purpose computer architectures, one or more FPUs may be integrated with the central processing unit; however many embedded processors do not have hardware support for floating-point operations.

===What is a cache?===
Clearing Computer Cache. The cache (pronounced "cash") is a space in your computer's hard drive and in RAM memory where your browser saves copies of previously visited Web pages. Your browser uses the cache like a short-term memory

===What is a bus?===
In computer architecture, a bus (related to the Latin "omnibus", meaning "for all") is a communication system that transfers data between components inside a computer, or between computers.

===Show the circuit diagram for A OR B AND C, NOT A AND B, <insert some other Boole formula here>?===

===Show the truth table for <insert Boole formula here>?===

Logical Conjunction(AND)

{| class="wikitable"

|-
|p
|q
|p ∧ q
|-
|T
|T
|T
|-
|T
|F
|F
|-
|F
|T
|F
|-
|F
|F
|F
|}

Logical Disjunction(OR)

{| class="wikitable"

|-
|p
|q
|p ∨ q
|-
|T
|T
|T
|-
|T
|F
|T
|-
|F
|T
|T
|-
|F
|F
|F
|}

Logical NAND

{| class="wikitable"

|-
|p
|q
|p ↑ q
|-
|T
|T
|F
|-
|T
|F
|T
|-
|F
|T
|T
|-
|F
|F
|T
|}

Logical NOR

{| class="wikitable"

|-
|p
|q
|p ↓ q
|-
|T
|T
|F
|-
|T
|F
|F
|-
|F
|T
|F
|-
|F
|F
|T
|}

===Write the equivalent Boole formula of a circuit diagram.===

==Publishing work==

===What are the major implications of MIT, BSD and GPL licenses?===
The MIT License is a free software license originating at the Massachusetts Institute of Technology (MIT). It is a permissive free software license, meaning that it puts only very limited restriction on reuse and has therefore an excellent license compatibility. The MIT license permits reuse within proprietary software provided all copies of the licensed software include a copy of the MIT License terms and the copyright notice. The MIT license is also compatible with many copyleft licenses as the GPL; MIT licensed software can be integrated into GPL software, but not the other way around.
While the MIT license was always an important and often used license in the FOSS domain, in 2015 according to Black Duck Software and GitHub data, it became the most popular license before GPL variants and other FOSS licenses.
Notable software packages that use one of the versions of the MIT License include Expat, the Mono development platform class libraries, Ruby on Rails, Node.js, jQuery and the X Window System, for which the license was written.

BSD licenses are a family of permissive free software licenses, imposing minimal restrictions on the redistribution of covered software. They have max 4 articles + header and footer.
*Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of the <organization> nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

The GNU General Public License (GNU GPL or GPL) is a widely used free software license, which guarantees end users (individuals, organizations, companies) the freedoms to run, study, share (copy), and modify the software. Software that allows these rights is called free software and, if the software is copylefted, requires those rights to be retained. The GPL demands both. The license was originally written by Richard Stallman of the Free Software Foundation (FSF) for the GNU Project. In other words, the GPL grants the recipients of a computer program the rights of the Free Software Definition and uses copyleft to ensure the freedoms are preserved whenever the work is distributed, even when the work is changed or added to. The GPL is a copyleft license, which means that derived works can only be distributed under the same license terms. This is in distinction to permissive free software licenses, of which the BSD licenses and the MIT License are the standard examples. GPL was the first copyleft license for general use.

===What are the differences between copyright, trademark, trade secret?===
“Intellectual property is something that is created by the mind.” Typically, we think of ideas as being created by the mind – but intellectual property does not protect bare ideas: rather, it is the expression or symbolic power/recognizability of the ideas that are protected.
Thus, it is the design of the rocket that is patented, not the idea of a rocket. It is the painting of the lake that is copyrighted, not the idea of a lake. And it is the consumer recognizable logo that is trademarked, not the idea of a logo. Intellectual property protects how we express and identify ideas in concrete ways – not the idea itself.

In particular:

'''Patents''': protect functional expressions of an idea – not the idea itself. A machines, method/process, manufacture, compositions of matter, and improvements of any of these items can be patented. Thus, I can patent a design for the nozzle on a rocket, or the method of making the rocket, or the method of making the rocket fuel, or the metal in which the rocket fuel is stored, or a new way of transporting the rocket fuel to the rocket. But I cannot patent the broad “idea” of a rocket.

'''Copyrights''': protect the specific creative expression of an idea through any medium of artistic/creative expression – i.e., paintings, photographs, sculpture, writings, software, etc. A copyright protects your painting of a haystack, but it would not prohibit another painter from expressing their artistry or viewpoint by also painting a haystack. Likewise, while Ian Fleming was able to receive a copyright on his particular expression of the idea of a secret agent (i.e., a debonair English secret agent), he could not prevent Rich Wilkes from receiving a copyright on his expression of the idea of a secret agent (i.e., a tattooed bald extreme athlete turned reluctant secret agent).

'''Trademarks''': protect any symbol that indicates the source or origin of the goods or services to which it is affixed. While a trademark can be extremely valuable to its owner, the ultimate purpose of a trademark is to protect consumers – that is, the function of a trademark is to inform the consumer where the goods or services originate. The consumer, knowing the origin of the goods, can make purchasing decisions based on prior knowledge, reputation or marketing.

'''Trade secret''': is a formula, practice, process, design, instrument, pattern, commercial method, or compilation of information which is not generally known or reasonably ascertainable by others, and by which a business can obtain an economic advantage over competitors or customers.[

While each category is distinct, a product (or components/aspects of a product) may fall into one or more of the categories. For example, software can be protected by both patents and copyrights. The copyright would protect the artistic expression of the idea – i.e., the code itself – while the patent would protect the functional expression of the idea – e.g., using a single click to purchase a book online. Likewise, it is likely that the software company will use a trademark to indicate who made the software.

An additional example would be a logo for a company. The logo may serve as a trademark indicating that all products affixed with the logo are from the same source. The creative and artistic aspects of the logo may also be protected by a copyright.

===Where would you use waterfall software development model? Where would you use agile?===

===What is the purpose of a version control system?===

Why Use a Version Control System?

There are many benefits of using a version control system for your projects. This chapter explains some of them in detail.

Collaboration

Without a VCS in place, you're probably working together in a shared folder on the same set of files. Shouting through the office that you are currently working on file "xyz" and that, meanwhile, your teammates should keep their fingers off is not an acceptable workflow. It's extremely error-prone as you're essentially doing open-heart surgery all the time: sooner or later, someone will overwrite someone else's changes.

With a VCS, everybody on the team is able to work absolutely freely - on any file at any time. The VCS will later allow you to merge all the changes into a common version. There's no question where the latest version of a file or the whole project is. It's in a common, central place: your version control system.

Other benefits of using a VCS are even independent of working in a team or on your own.

Storing Versions (Properly)

Saving a version of your project after making changes is an essential habit. But without a VCS, this becomes tedious and confusing very quickly:

How much do you save? Only the changed files or the complete project? In the first case, you'll have a hard time viewing the complete project at any point in time - in the latter case, you'll have huge amounts of unnecessary data lying on your hard drive.
How do you name these versions? If you're a very organized person, you might be able to stick to an actually comprehensible naming scheme (if you're happy with "acme-inc-redesign-2013-11-12-v23"). However, as soon as it comes to variants (say, you need to prepare one version with the header area and one without it), chances are good you'll eventually lose track.
The most important question, however, is probably this one: How do you know what exactly is different in these versions? Very few people actually take the time to carefully document each important change and include this in a README file in the project folder.
A version control system acknowledges that there is only one project. Therefore, there's only the one version on your disk that you're currently working on. Everything else - all the past versions and variants - are neatly packed up inside the VCS. When you need it, you can request any version at any time and you'll have a snapshot of the complete project right at hand.

Restoring Previous Versions

Being able to restore older versions of a file (or even the whole project) effectively means one thing: you can't mess up! If the changes you've made lately prove to be garbage, you can simply undo them in a few clicks. Knowing this should make you a lot more relaxed when working on important bits of a project.

Understanding What Happened

Every time you save a new version of your project, your VCS requires you to provide a short description of what was changed. Additionally (if it's a code / text file), you can see what exactly was changed in the file's content. This helps you understand how your project evolved between versions.

Backup

A side-effect of using a distributed VCS like Git is that it can act as a backup; every team member has a full-blown version of the project on his disk - including the project's complete history. Should your beloved central server break down (and your backup drives fail), all you need for recovery is one of your teammates' local Git repository.

===What would you store in a version control system?===

==Algorithms and data structures==

===What is time complexity of algorithm?===
In computer science, the time complexity of an algorithm quantifies the amount of time taken by an algorithm to run as a function of the length of the string representing the input. Time complexity is commonly estimated by counting the number of elementary operations performed by the algorithm, where an elementary operation takes a fixed amount of time to perform.

===What is space complexity of algorithm?===
Space complexity is a measure of the amount of working storage an algorithm needs. That means how much memory, in the worst case, is needed at any point in the algorithm.
It represents the total amount of memory space that a "normal" physical computer would need to solve a given computational problem with a given algorithm.

===What's a good algorithm?===
It executes as fast as possible.
It takes as less space as possible.
It is adaptable to computers.
It is simple.
It is elegant (well written).

==History==

===What is [https://en.wikipedia.org/wiki/Moore's_law Moore's law]? What is [https://en.wikipedia.org/wiki/Rock's_law Rock's law]?===
Moore's law is the observation that the number of transistors in a dense integrated circuit doubles approximately every two years. The observation is named after Gordon E. Moore, the co-founder of Intel and Fairchild Semiconductor, whose 1965 paper described a doubling every year in the number of components per integrated circuit, and projected this rate of growth would continue for at least another decade. In 1975, looking forward to the next decade, he revised the forecast to doubling every two years.
Rock's law or Moore's second law, named for Arthur Rock or Gordon Moore, says that the cost of a semiconductor chip fabrication plant doubles every four years. As of 2015, the price had already reached about 14 billion US dollars.

===What were the major contributing factors for success of Microsoft, Apple, Google, <your favourite company>?===

===What were the major contributing factors to the success of Silicon Valley?===

Exam help

2016-01-11T20:26:09Z

Smets: /* Explain how cathode ray tube (CRT) based screen technology works and name pros/cons. */

Exam help

2016-01-11T18:44:00Z

Smets: /* What happens during context switch? */

Exam help

2016-01-11T17:15:20Z

Smets: /* What are the main differences between real mode and protected mode of x86-based processor? */

Exam help

2016-01-11T17:04:30Z

Smets: /* Explain step by step how operating system is booted up, see slides for flowchart. */

Exam help

2016-01-11T17:03:17Z

Smets: /* BIOS */

Exam help

2016-01-11T17:02:54Z

Smets: /* Explain step by step how operating system is booted up, see slides for flowchart. */

Exam help

2016-01-11T17:00:21Z

Smets: /* Explain step by step how operating system is booted up, see slides for flowchart. */

Category:I600 Introduction to Computers and Informatics

2016-01-03T13:27:19Z

Smets: /* Grading */

In this course we'll give an introduction to variety of topics from hardware to software.
The course will follow roughly the same structure as [https://lagunita.stanford.edu/courses/Engineering/CS101/Summer2014/about Computer Science 101 at Stanford University] with more hands-on approach. This course substitutes Estonian courses I100 Sissejuhatus informaatikasse and [http://www.pld.ttu.ee/~teet/itarvutid.html I201 Arvutid].

Monday lectures will cover more theoretical stuff;
Thursday workshops are for getting started with new topics;
the homework assignments connect theoretical with practice and
Tuesday sessions are for follow up, asking/answering questions and presenting homework.
Attendance won't be tracked, the sessions are there if you need help.
Bring your laptops for Tuesday and Thursday sessions.

Course credits: 6 ECTS

Lecturer: Lauri Võsandi

E-mail: lauri [donut] vosandi [plus] i600 [ät] gmail [dotchka] com

=Grading=

Grade mapping:

* 0-50 points, fail
* 51-60 points, pass 1
* 61-70 points, satisfactory 2
* 71-80 points, average 3
* 81-90 points, good 4
* 91-100 points, very good 5

Grading is split between theory and practice

* Exam of 50 points, preparation in lectures and general discussion in workshops.
* Assignments, see instructions and points below.
* Extra points for improving quality of wiki articles, extracurricular work and also helping others, see points below.

Exam will be halfway between oral and written: You'll be given 30 minutes to prepare for several random questions and 15 minutes to discuss what you've answered.
If you don't have prior experience with the topics, it's highly recommended to take part of the sessions in order to pass the exam. You can use a calculator and this wiki page, don't rely on the access to terminal or other software tools. You can not access Internet or any remote computers.

Exam sections:

* Execution of ~10 processor instructions
* Bunch of randomly selected questions from this page
* Bunch of questions (how much RAM, how big disk, what wireless chipset) asked about a computer you'll be given
* Gain SSH access to a machine on the network, basic text file editing skills using nano

Exam times:

* 12. jan 10:00 - Oliver Aasmets
* 12. jan 10:30 - <Insert name>
* 12. jan 11:00 - <Insert name>
* 12. jan 11:30 - <Insert name>
* 12. jan 13:00 - Artur V. Kerge
* 12. jan 13:30 - <Insert name>
* 12. jan 14:00 - Nazmul Hasan
* 12. jan 14:30 - <Insert name>
* 12. jan 15:00 - Meelis Hass
* 12. jan 15:30 - <Insert name>
* 13. jan 10:00 - <Insert name>
* 13. jan 10:30 - <Insert name>
* 13. jan 11:00 - <Insert name>
* 13. jan 11:30 - <Insert name>
* 13. jan 13:00 - <Sheela Gowry>
* 13. jan 13:30 - Dmitri Sim
* 13. jan 14:00 - Ender
* 13. jan 14:30 - Sander Mets
* 13. jan 15:00 - <Insert name>
* 13. jan 15:30 - Mohanad Aly

=Lecture: Computer hardware=

Jargon: CPU, RAM, ROM, HDD, SSD, PCI, PCI Express, USB 2.0, USB 3.0, VGA, HDMI, DVI, LCD, TFT, LED, OLED, AMOLED, CRT, PWM

[https://echo360.e-ope.ee/ess/echo/presentation/beef71c3-044c-43c9-a326-e1e62cbb5c9b Lecture recording #1]

[https://echo360.e-ope.ee/ess/echo/presentation/36786bbb-84b6-4604-be6f-c363bf22ce8d Lecture recording #2 starting 12:30]

[https://docs.google.com/presentation/d/1OzaqTBAUfMOzhG0HZeSJVSszCmFyn4ug35teYJWkyfM/edit?usp=sharing Lecture slides] Random access memory, permanent storage, buses, input devices, display technologies, networking

Potential exam questions:

* Different buses and their uses
* What are the differences between hard disk drive (HDD) and solid state drive (SSD)? [http://www.storagereview.com/ssd_vs_hdd]
* What is the purpose of Flash Translation Layer in terms of solid state drives?
* What are difference between volatile/non-volatile, RAM, ROM, EEPROM and where are they used?
* What is data retention?
* What are difference between asynchronous/synchronous, dynamic/static RAM and where are they used?
* What is [https://compsci2014.wikispaces.com/2.1.3+Explain+the+use+of+cache+memory cache]? What is cache coherence?
* What are differences between resistive and capacitive touchscreen? [http://www.alphr.com/realworld/357325/capacitive-or-resistive-whats-the-best-type-of-touchscreen]
* Explain how [http://www.bidouille.org/hack/mousecam computer mouse] works? [http://www.topdesignmag.com/mouse-history-in-photos/ History of computer mouse].
* Explain how [http://www.daskeyboard.com/blog/typing-through-time-the-history-of-the-keyboard/ computer keyboard] works? [http://computer.howstuffworks.com/keyboard.htm HowStuffworks article] [http://www.explainthatstuff.com/computerkeyboards.html Explain that Stuff article] [http://www.daskeyboard.com/blog/typing-through-time-the-history-of-the-keyboard/ Keyboard History]
* Explain how [https://en.wikipedia.org/wiki/Cathode_ray_tube cathode ray tube] (CRT) based screen technology works and name pros/cons. [https://www.youtube.com/watch?v=2czqYV3T_Kc]
* Explain how [https://en.wikipedia.org/wiki/Liquid-crystal_display liquid crystal displays] (LCD) work and name pros/cons. [https://www.youtube.com/watch?v=nCHgmCxGEzY]
* Name screen technologies making use of thin film transistor (TFT) technology? [https://en.wikipedia.org/wiki/Thin-film_transistor]
* Name uses for light polarization filters? [https://en.wikipedia.org/wiki/Polarizing_filter_%28photography%29] [https://en.wikipedia.org/wiki/Polarized_3D_system]
* What are the benefits of [https://en.wikipedia.org/wiki/Twisted_pair twisted pair cabling] and [https://en.wikipedia.org/wiki/Differential_signaling differential signalling]?
* [https://en.wikipedia.org/wiki/Active_matrix Active matrix] vs [https://en.wikipedia.org/wiki/Passive_matrix_addressing passive matrix] in display technology

Security section: [http://www.bunniestudios.com/blog/?p=3554 Hacking SD cards]

Assignments:
* [https://wiki.itcollege.ee/index.php/I600_Introduction_to_Computers_and_Informatics#Assignment:_Investigating_PC_hardware Investigating PC hardware]
* [https://wiki.itcollege.ee/index.php/I600_Introduction_to_Computers_and_Informatics#Assignment:_Investigating_embedded_hardware Investigating embedded hardware]

=Lecture: Storage abstractions=

In this lecture we'll talk about permanent storage abstractions: block device, disk, partition, file system, directory/folder, file, journaling, FAT32, NTFS, ext4, HFS+

[https://docs.google.com/presentation/d/1dJ-HMSR9nW8OuZtSTYf5dlFyPsZKGqxlKoEwIHi9h6k/ Lecture slides]

[https://echo360.e-ope.ee/ess/echo/presentation/36786bbb-84b6-4604-be6f-c363bf22ce8d Lecture recording] starts at 47:50.

* What is a [https://en.wikipedia.org/wiki/Block_%28data_storage%29 block device]?
* What is [https://en.wikipedia.org/wiki/Logical_block_addressing logical block addressing] and what are the benefits compared to older [https://en.wikipedia.org/wiki/Cylinder-head-sector cylinder-head-sector addressing] method in terms of harddisks?
* What is a [https://en.wikipedia.org/wiki/Disk_partitioning disk partition]?
* What is a [https://en.wikipedia.org/wiki/File_system file system]?
* What is [https://en.wikipedia.org/wiki/Journaling_file_system#Write_hazards journaling] in terms of filesystems and what are the benefits? Name some journaled filesystems in use nowadays.

=Lecture: Bootloaders, kernels=

In this lecture we'll discuss how a computer boots and how an operating system kernel is loaded.

[https://echo360.e-ope.ee/ess/echo/presentation/04eeebd1-c892-485a-9123-03abaa3ce3ca Lecture recording #1], first half we'll discuss about first assignment about investigating PC hardware, slides start at 43:40.

[https://echo360.e-ope.ee/ess/echo/presentation/26f1d40d-7830-4e5c-b783-e061c1e91cfc Lecture recording #2], first 15 minutes we'll discuss about second assignment about investigating embedded hardware, last slides about kernels are discussed from 16:00 up to 27:30. I forgot to switch video input for lecture recording so you'll have to browse slides from the link below :/

Lecture slides:
[https://docs.google.com/presentation/d/1ybYQEqCgN1KdVW1sLdwtfRogavgzzMQdUfTcAnxNAf4/ bootloaders],
[https://docs.google.com/presentation/d/1xDL27k3z_0I-IKzdjKkwhOhBrg0aOnM0w0u1zDwaEWY/ kernels].

Jargon: [https://en.wikipedia.org/wiki/BIOS BIOS] (basic input/output system), [https://en.wikipedia.org/wiki/Unified_Extensible_Firmware_Interface UEFI] (Unified Extensible Firmware Interface), bootloader, kernel, process, context switch, x86 real/protected mode, paged virtual memory, swap/pagefile, [https://en.wikipedia.org/wiki/User_space kernelspace/supervisor mode, userspace], [https://en.wikipedia.org/wiki/Protection_ring#Hypervisor_mode hypervisor mode] (ring -1), [https://en.wikipedia.org/wiki/System_Management_Mode#Problems system management mode] aka (ring -2).

Potential exam questions:

* What is the role of BIOS/UEFI in x86-based machines?
* Explain step by step how operating system is booted up, see slides for flowchart.
* Describe the functionality provided by general purpose operating system. See architecture of [https://en.wikipedia.org/wiki/Architecture_of_Windows_NT Windows NT], [http://www.elinux.org/Android_Architecture Android], [https://en.wikipedia.org/wiki/Architecture_of_OS_X OS X].
* What are the main differences between [https://en.wikipedia.org/wiki/Real_mode real mode] and [https://en.wikipedia.org/wiki/Protected_mode protected mode] of x86-based processor?
* What happens during context switch?
* What is the purpose of [https://en.wikipedia.org/wiki/Virtual_memory paged virtual memory]?

Security section: [https://en.wikipedia.org/wiki/DMA_attack DMA attack], [http://www.outsidaz.org/blog/2007/10/22/resetting-root-password-via-grubkernel-boot-options/ editing GRUB entries to gain root shell] without password prompt, [http://www.theinquirer.net/inquirer/news/2421402/serious-intel-cpu-security-exploit-spotted-in-old-x86-chips 20 years old security exploit in x86 processors].

=Lecture: Libraries, frameworks=

[https://echo360.e-ope.ee/ess/echo/presentation/26f1d40d-7830-4e5c-b783-e061c1e91cfc Lecture recording #1], from 00:27:30 up to 1:04:00.

[https://docs.google.com/presentation/d/1q9kGg5AI3AyXglxpJdLjLMpgRLdbF9dl62gauNmDEG8/edit Lecture slides]

Jargon: framework, library, [https://en.wikipedia.org/wiki/Application_binary_interface ABI], [https://en.wikipedia.org/wiki/Application_programming_interface API]

Security section: [http://www.fiercecio.com/story/hackers-exploiting-httpsys-bug-crash-iis-web-servers/2015-04-17 HTTP.sys bug crashes IIS web servers], [http://heartbleed.com/ OpenSSL bug Heartbleed].

=Lecture: Programming languages=

In this lecture we'll talk about programming languages

Lecture recording: [https://echo360.e-ope.ee/ess/echo/presentation/26f1d40d-7830-4e5c-b783-e061c1e91cfc starting from 1:04:00]

Lecture slides: [https://docs.google.com/presentation/d/1CCZntY7Z-AG_Mice5N2kclDGYI2xVVvRHgWUIs-SxYo/edit programming languages, stack machine]

Jargon: stack machine, lexer/lexeme, token, abstract syntax tree

Potential exam questions:

* What are the major steps of compilation?
* What are the differences between [https://en.wikipedia.org/wiki/Interpreted_language interpreted], [https://en.wikipedia.org/wiki/Just-in-time_compilation JIT-compilation] and [https://en.wikipedia.org/wiki/Compiler traditional compiling]?
* What is [https://en.wikipedia.org/wiki/Control_flow control flow]? Loops? Conditional statements?

Assignments:

* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Disassembling_Python Disassembling Python]
* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Investigating_compilers Investigating compilers]

=Lecture: Data encoding=

[https://echo360.e-ope.ee/ess/echo/presentation/ca8310e9-e82e-4e47-b90a-2e1801bcfada Lecture recording]

[https://docs.google.com/presentation/d/1QV_IMOadIEUTBW7Laqw59j8J7Y8HKwvSDmP-swEEx0s Lecture slides]

In this lecture we'll talk about bits, bytes, integers, strings, pixels, audio encodings, video encoding etc.

Potential exam questions:

* What is bit? Nibble? Byte? Word?
* Write 9375 in binary, hexadecimal?
* Write 0xDEADBEEF in decimal?
* What is [https://en.wikipedia.org/wiki/Quantization_%28signal_processing%29 quantization] in terms of signal processing?
* How are [https://en.wikipedia.org/wiki/Integer_%28computer_science%29 integers] stored in binary? What integer range can be described using n bits? How many bits are required to describe integer range from n .. m.
* How are [https://en.wikipedia.org/wiki/Single-precision_floating-point_format single precision] and [https://en.wikipedia.org/wiki/Double-precision_floating-point_format double precision] floating point numbers stored in binary according to [https://en.wikipedia.org/wiki/IEEE_floating_point IEEE754 standard]? [http://lauri.vosandi.com/hdl/arithmetic/floating-point-representation.html Floating-point multiplication]
* What is the difference between CMYK and RGB color models? How are YUV, HSV and HSL colorspaces related to RGB? What are sRGB and YCbCr and where are they used?
* How is data encoded on audio CD-s? What is the [http://lauri.vosandi.com/2013/07/audio-codecs.html capacity of an audio CD]?
* What is sampling rate? What is bit depth? What is resolution?
* What is bitrate?
* What is lossy/lossless compression?
* What is JPEG suitable for? Is JPEG lossy or lossless compression method?
* What is PNG suitable for? Does PNG support compression?
* How are time domain and frequency domain related in terms of signal processing? What is Fourier transform and where it is applied?

Jargon: 44.1kHz sampling rate, 16-bit audio, RGB565 pixel format, RGB888 pixel format

Relevant assignments:

* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Disassembling_Python Disassembling Python]
* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Investigating_compilers Investigating compilers]

=Lecture: Code execution in processor=

[https://docs.google.com/presentation/d/18wPDLydyZevMi9F0MX7F6eK-NMBZQzGN4mviF_ft8-E/edit Lecture slides]

[https://echo360.e-ope.ee/ess/echo/presentation/41440769-1cd5-4166-bd4e-299c2af3d3e0?ec=true Lecture recording #1]

[https://echo360.e-ope.ee/ess/echo/presentation/7aeb2a04-b0dc-4547-9dee-e541a5f9c99a?ec=true Lecture recording #2] up to 8:35, system calls

It's highly reccommended to play around with simulators [http://morriswmz.jit.su/static/simple-mips-pipelined.html here is one for MIPS processors].

In this lecture we'll talk about different processor architectures, instructions, pipelining, function calls, jumps, loops etc.

Assignments:

* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Disassembling_Python Disassembling Python]
* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Investigating_compilers Investigating compilers]

Exam question:

* Given ~10 instructions and their explainations, follow the instructions and elaborate after every step what happened in the processor?

=Lecture: Microcontrollers=

[https://docs.google.com/presentation/d/1qPyzBBfB1TseEzXjcp4-ZjqSnAwbjDmEqyIYcUGFLG0/edit Lecture slides]

[https://echo360.e-ope.ee/ess/echo/presentation/7aeb2a04-b0dc-4547-9dee-e541a5f9c99a?ec=true Lecture recording] starts at 8:35

Jargon: microprocessor, microcontroller, coprocessor, floating-point unit (FPU), digital signal processor (DSP), field programmable grid array (FPGA), sensors, actuators, digital input/output, analog input, general purpose input/output (GPIO), interrupt, interrupt handler, timer/counter, pulse-width modulation (PWM),

Potential exam question:

* What distinguishes microcontroller from microprocessor?
* What are the differences between Hardvard architecture and von Neumann architecture?
* What is an interrupt?
* What is an timer?

=Lecture: Introduction to Boole algebra=

[https://docs.google.com/presentation/d/1Y1rXvt2oXROhW-LZ07B0Sg90D-_u8SlLUZeaxds7f1g/ Lecture slides]

Exam questions:

* Simplify A AND A OR B
* Show addition of X and Y in binary
* Show subtraction of X and Y in binary
* Show multiplication of X and Y in binary

Assignments:
* [https://wiki.itcollege.ee/index.php/Category:I600_Introduction_to_Computers_and_Informatics#Assignment:_Designing_arithmetic-logic_unit Designing arithmetic-logic unit]

=Lecture: Hardware description languages=

[https://docs.google.com/presentation/d/1HO9iPfi8S3ZykuW7IHVm09QamLHiVo6s6lUGwWu4eD4/ Lecture slides]

[https://echo360.e-ope.ee/ess/echo/presentation/b7ca9eb3-5a9d-4e8c-8c1b-25c2891359ee Lecture recording] starts at 05:00

Potential exam questions:

* What are the uses for hardware description languages?
* What is latch?
* What is flip-flop?
* What is mux (multiplexer)?
* What is register? Register file?
* What is ALU?
* What is floating-point unit?
* What is a cache?
* What is a bus?
* Show the circuit diagram for A OR B AND C, NOT A AND B, <insert some other Boole formula here>?
* Show the truth table for <insert Boole formula here>?
* Write the equivalent Boole formula of a circuit diagram.

=Lecture: Publishing work=

[https://echo360.e-ope.ee/ess/echo/presentation/cd2c0e2b-5f48-4a39-89ca-b75801e5d00b Lecture recording]

[https://docs.google.com/presentation/d/1hCqRjGUx5Yv6iZN4xaz2UICLWbycnM46ctw2zX0g94U/ Lecture slides]

Potential exam questions:

* What are the major implications of MIT, BSD and GPL licenses?
* What are the differences between copyright, trademark, trade secret?
* Where would you use waterfall software development model? Where would you use agile?
* What is the purpose of a version control system?
* What would you store in a version control system?

=Lecture: Algorithms and data structures=

[https://echo360.e-ope.ee/ess/echo/presentation/1145600e-cef9-40b4-91da-3cc1174e27eb Lecture recording] unfortunately without audio :(

[https://docs.google.com/presentation/d/1vwJvvRerM0rYBaiE3pEX5GUXRHuVJvjTUDKo8fqTq_A/ Lecture slides]

Potential exam questions:

* What is time complexity of algorithm?
* What is space complexity of algorithm?
* What's a good algorithm?

=Lecture: History=

Topics: Computer history, Silicon Valley, standards

[https://echo360.e-ope.ee/ess/echo/presentation/584b21e6-4ead-4cb6-bc41-5c653bc5c3a2 Lecture recording]

[https://docs.google.com/presentation/d/1Ybld2ABpm9QJSLL-Bodr1a5XI5Hk_KM2q_nZVYu2L0c/edit?usp=sharing Lecture slides]

Potential example questions:

* What is [https://en.wikipedia.org/wiki/Moore's_law Moore's law]? What is [https://en.wikipedia.org/wiki/Rock's_law Rock's law]?
* What were the major contributing factors for success of Microsoft, Apple, Google, <your favourite company>?
* What were the major contributing factors to the success of Silicon Valley?

=Assignment: Investigating PC hardware=

Goal: Get familiar with your [https://en.wikipedia.org/wiki/X86 laptop hardware]. Get out of the comfort zone of your primary operating system and try out other operating systems. Learn about [https://en.wikipedia.org/wiki/Full_virtualization hardware virtualization].

Deadline: 16. September

Credits: 5 points plus extra point for being extra thorough about interpreting what you see.

Use what you learned in [[Getting started with Ubuntu]] workshop:

* '''Read the instructions before you act'''.
* Place your preferred ISO image to a memory stick using <code>dd</code> or Win32 Disk Imager and boot it on your personal laptop. You do '''not''' need to install Ubuntu on your harddisk, simply click '''Try Ubuntu''' once the operating system boots off the memory stick and carry out following tasks.
* Open up terminal by pressing <code>Ctrl-Alt-T</code>.
* Use <code>lsb_release -a</code> to check what operating system distribution you're running.
* Use <code>uname -sr</code> to check what operating system kernel you're running.
* Use <code>cat /proc/cpuinfo</code> and check processor information. What CPU model and how many cores your computer has?
* Use <code>arch</code> to check what CPU architecture is being used by the operating system. Is it 32-bit or 64-bit?
* Use <code>cat /proc/meminfo</code> to check memory usage. How much RAM your computer has?
* Use <code>lspci -t -v -nn</code> to enumerate PCI and PCI Express devices, attempt to identify what is what.
* Use <code>lsusb</code> and <code>lsusb -t</code> to enumerate USB devices, again attempt to identify what is what.
* Use <code>fdisk -l</code> to enumerate disks and partitions. How big is your harddisk? How many and how big partitions it has?
* Use <code>lsblk</code> to enumerate block devices.
* Use <code>xrandr</code> to enumerate display outputs. What video output resolutions are available and which one is currently used?
* Use <code>cat /proc/asound/cards</code> to check which audio devices are available.
* Use <code>dmidecode</code> to see even more information about your computer.
* Use <code>ifconfig -a</code> or <code>ip addr list</code> to list all network interfaces.
* Use <code>iwconfig</code> or <code>iw list</code> to list all wireless network interfaces. Is your wireless network interface detected? If not take a guess why?
* Use <code>hcitool dev</code> to list bluetooth host controller. Is your bluetooth device detected?
* Use <code>glxinfo</code> to check what 3D rendering capabilities are available, is it hardware accelerated? (hint: is direct rendering enabled?)
* What [https://en.wikipedia.org/wiki/Sound_card audio card] is your machine using? What bus is it using?
* What [https://en.wikipedia.org/wiki/Graphics_processing_unit graphics controller] is your machine using? What bus is it using?
* What webcam is your machine using? What bus is it using?
* What [https://en.wikipedia.org/wiki/Ethernet wired network] chipset your computer has? What bus is it using?
* What [https://en.wikipedia.org/wiki/IEEE_802.11 wireless network] chipset your computer has? What bus is it using?
* What [https://en.wikipedia.org/wiki/Bluetooth Bluetooth] device your computer has? What bus is it using?
* Is there a [https://en.wikipedia.org/wiki/Mobile_broadband_modem cellular modem] connected and how it's connected?
* Boot the ISO image in VirtualBox and follow the same steps as above, '''what are the differences and why'''?
* Answer to questions above and send it as [https://en.wikipedia.org/wiki/Plain_text plain text] e-mail to Lauri, make sure you '''use the address supplied above with the course code''', otherwise your mail is not searchable in my mailbox. Attach collected command outputs as [https://en.wikipedia.org/wiki/Plain_text plain text] file, do '''not''' send .odt, .doc files, these are not readable on my smartphone. When answering to questions phrase the text in a way that is understandable out of context, so I don't have to open up wiki to understand what you're talking about.

Note that I can't expect you to install Ubuntu on your physical machine, but I can help if you want to do that. You should have Ubuntu ready to go in a virtual machine at least for subsequent sessions. We're using Ubuntu because it's widely used on servers and in the cloud, so any Ubuntu skills will definitely come handy in future. If you're already familiar with Linux, it's suggested to take a look at other interesting operating systems such as [https://www.freebsd.org/ FreeBSD] or [http://www.openbsd.org/ OpenBSD]. Take a look at [https://www.kali.org/ Kali Linux] if you're interested in penetration testing.

=Assignment: Investigating embedded hardware=

Background: Most of the smartphones nowadays are using [https://en.wikipedia.org/wiki/System_on_a_chip SoC] built around [https://en.wikipedia.org/wiki/ARM_architecture ARM] processor. Raspberry Pi is an excellent piece of hardware to for checking out how an ARM-based machine looks like.

Goal: Get familiar with hardware ARM-based hardware.

Deadline: 23. September

Points: 4 points

Use what you learned in [[Getting started with Ubuntu]] and [[Getting started with Raspberry Pi]] workshops:

* Read the instructions before you get busy.
* Boot Raspbian on Raspberry Pi.
* Use the commands described in previous assignment to examine the environment of Raspbian on Raspberry Pi. What are the major differences compares to your laptop and virtual machine?
* What buses is Raspberry Pi making use of?
* What filesystems is Raspbian making use of?
* Answer to questions above and send it as e-mail to Lauri, make sure you '''use the address supplied above with the course code''', otherwise your mail is not searchable in my mailbox. Attach collected command outputs as [https://en.wikipedia.org/wiki/Plain_text plain text] file, do '''not''' send .odt, .doc files, these are not readable on a phone. When answering to questions phrase the text in a way that is understandable out of context, so it is not necessary to open up wiki to understand what you're talking about.

=Assignment: Investigating LAMP=

[https://en.wikipedia.org/wiki/LAMP_%28software_bundle%29 LAMP] software bundle is consists of Linux-based OS, [https://en.wikipedia.org/wiki/Apache_HTTP_Server Apache web server], [https://en.wikipedia.org/wiki/PHP PHP programming language] runtime and [https://en.wikipedia.org/wiki/MySQL MySQL database].
Most of the web applications on the Internet including Facebook are built on top of LAMP-styled software stack.
Use a Raspberry Pi or Ubuntu virtual machine to set up [https://www.raspberrypi.org/learning/lamp-web-server-with-wordpress/ WordPress], [https://doc.owncloud.org/server/8.1/admin_manual/installation/index.html ownCloud] or any well-known web application that makes use of a database such as MySQL.
To make your life easier also set up SSH public key authentication.

Goal: Get familiar with LAMP stack. Get comfortable with (SSH) public key authentication.

Deadline: 30. September

Points: 4 points

Tasks:

* If you're using Ubuntu virtual machine approach, see [[Accessing a virtual machine via SSH connection]]
* Use SSH to connect to your server over the network. If you're using Windows on your laptop use [http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY] to gain access to command line and [https://winscp.net/ WinSCP] to copy files, otherwise simply boot Ubuntu in a virtual machine and use <code>ssh username@hostname</code> to invoke commands and <code>sftp://username@hostname</code> in the file browser to access filesystem.
* Set up any of the web applications referenced above. You may be interested in reading also [http://howtoubuntu.org/how-to-install-lamp-on-ubuntu this] and [https://www.digitalocean.com/community/tutorials/how-to-install-wordpress-on-ubuntu-14-04 this].
* Demonstrate that the web application you installed works in next Tuesday session, screenshots/photos with explanation sent to e-mail above also suffice.
* Optional: Set up SSH public key authentication to <code>enos.itcollege.ee</code>.
* Optional: [https://www.raspberrypi.org/documentation/remote-access/ssh/passwordless.md Set up public key authentication to your Raspberry Pi]. Windows users might want to take a look at [https://winscp.net/eng/docs/ui_puttygen#obtaining_and_starting_puttygen PuTTYgen instructions].

Note: You don't have to necessarily use Raspberry Pi - Web application installed in Ubuntu VM is also accepted, also if you're maintaining similar installation of a production server that is accepted as well. [http://www.wampserver.com/en/ WAMP] on Windows is also accepted.

=Assignment: Set up basic IoT scenario=

[https://en.wikipedia.org/wiki/Internet_of_Things Internet of Things] is one of the emerging technologies (read: hype). IoT is essentially about getting everything online, including lightbulbs, switches, window shades etc. In this assignment LED symbolizes a light and the task is to implement code which allows user to switch the LED on and off over the network.

[[File:Raspberry-pi-gpio-18-led bb.png|600px]]

Goal: Get familiar how Python code can be started up. Build basic [https://en.wikipedia.org/wiki/Internet_of_Things IoT] appliance, a light that can be turned on and off via the Internet.

Deadline: 7. October

Points: 4 points

* Complete the [http://codeacademy.com/tracks/python Python track at CodeAcademy] if you haven't done that yet.
* Follow the wiki page Blinking LED section under [[Getting started with Raspberry Pi]].
* Get an LED blinking on command-line.
* Get LED blinking from Python code.
* Get basic HTTP server running in Python.
* Combine all of the above, build an HTTP server that can be used to turn LED on and off from via web browser.
* Optional: Take a peek at next assignment and upload working version to GitHub.
* Optional: [http://sourceforge.net/p/raspberry-gpio-python/wiki/PWM/ Smoothen the transitions using PWM].

=Assignment: Collaborating using Git=

Software development is usually done by several contributors, to facilitate efficient collaboration a distributed version control system is a must. In this assignment you'll upload your code to GitHub and modify fellow student's code to reflect changes in the Raspberry Pi setup:

[[File:Raspberry-pi-rgb-led bb.png|600px]]

Deadline: 14. October

Points: 5

Goal: Get familiar with distributed version control systems. Collaborate.

* Create [https://github.com/ GitHub] account if you haven't done so yet.
* Create a Git repository, eg http://github.com/your-username/rpi-iot-example
* Install Git on your Raspberry Pi by using <code>apt-get install git</code>.
* Clone the repository to your Raspberry Pi using <code>git clone http://github.com/your-username/rpi-iot-example</code>.
* Move the Python code created earlier to the Git repository directory.
* Use <code>git add</code> to add the files.
* Configure full name: <code>git config --global user.name "Firstname Surname"</code>
* Configure e-mail: <code>git config --global user.email first.last@domain.tld</code>
* Use <code>git commit</code> to create the [http://blog.no-panic.at/2014/10/20/funny-initial-git-commit-messages/ initial commit].
* Use <code>git push</code> to push the commits to GitHub server.
* Set up [https://help.github.com/articles/generating-ssh-keys/ public key authentication between your laptop and GitHub servers], verify that <code>https://github.com/username.keys</code> gives the expected result.
* Use <code>git clone</code> to clone the repository to your laptop. Ubuntu should first <code>apt-get install git</code>, Windows and Mac users might want to take a look at [http://git-scm.com/download/ Git homepage]. If you're looking for graphical user interface take a look at [https://desktop.github.com/ GitHub Desktop] or [https://tortoisegit.org/ TortoiseGit].
* Create [https://en.wikipedia.org/wiki/README README] in the repository directory, populate it with relevant content - what is it about, who made it etc and commit the changes.
* In your Raspberry Pi setup replace the single-color LED with RGB LED as shown above.
* Clone '''fellow student's''' repository and adapt the code to reflect physical changes to the setup, the Python snippet should now permit changing the color of the light, have it blinking and turn it off. Other interesting modes are awarded with extra points.
* Use either [https://www.atlassian.com/git/tutorials/ Atlassian Tutorials], [http://rogerdudler.github.io/git-guide/ git - the simple guide] or [https://try.github.io/ Try Git] as a reference if you get lost.
* Document in the README what GPIO pins are used in the code for red, green and blue. Extra points for making the Python code [https://docs.python.org/2/library/argparse.html#module-argparse configurable from command-line].
* Late submissions will heavily lose points for failure to comply with [http://chris.beams.io/posts/git-commit/ decent commit messages].
* Send Lauri the URL of your repository at GitHub.

Git resources: [http://git-scm.com/book/en/v2 Pro Git Book] (read the basics to get kickstarted) and [https://www.codecademy.com/en/courses/learn-git/ Codecademy Git course].

=Assignment: Disassembling Python=

CPython is the default, most widely used implementation of the Python programming language. CPython is written in C. CPython compiles Python source into bytecode which is interpreted by a Python virtual (stack) machine. This is very similar to what is done with Java. Use [https://docs.python.org/2/library/dis.html dis] to disassemble a Python function into stack machine instructions. Follow [https://docs.python.org/2/library/dis.html#python-bytecode-instructions bytecode instructions] to determine what each instruction does.

Deadline: 21. October

==Example submission==

Consider following Python function, which calculates the sum of squares. For example sum_of_powers(2, 3) == 14 (1**2 + 2**2 + 3**2):

def sum_of_powers(exponent, numbers):
counter = 1
return_value = 0
while True:
if counter > numbers:
break
return_value += counter ** exponent
counter += 1
return return_value

# Following two lines are the ones which produce the instructions shown below
from dis import dis
dis(sum_of_powers)

Corresponding Python stack machine instructions extracted with <code>dis</code> are following. Columns correspond to: line number in the source code, instruction offset (in bytes), instruction name as listed [https://docs.python.org/2/library/dis.html in dis documentation],

22 0 LOAD_CONST 1 (1) # Constant of 1 is pushed to stack
3 STORE_FAST 2 (counter) # Pushed value is popped and stored in variable counter

23 6 LOAD_CONST 2 (0) # Constant of 0 is pushed to stack
9 STORE_FAST 3 (return_value) # Pushed value is popped and stored in variable return_value

24 12 SETUP_LOOP 43 (to 58) # Loop until instruction no 58 is set up

25 >> 15 LOAD_FAST 2 (counter) # Value of variable <counter> is pushed to stack
18 LOAD_FAST 1 (numbers) # Value of variable <numbers> is pushed to stack
21 COMPARE_OP 4 (>) # Two topmost values of stack are popped and compared,
# boolean result is pushed back to the top of stack
24 POP_JUMP_IF_FALSE 31 # If top of the stack if False,
# jump to instruction no 31 is performed.
# Top of the stack is popped

26 27 BREAK_LOOP # Execution jumps out of the loop, the one
# that was set up at inst no 12
28 JUMP_FORWARD 0 (to 31) # Placeholder probably due to the way pipeline is handled

27 >> 31 LOAD_FAST 3 (return_value) # Value of variable <return_value> is pushed to stack
34 LOAD_FAST 2 (counter) # Value of variable <counter> is pushed to stack
37 LOAD_FAST 0 (exponent) # Value of variable <exponent> is pushed to stack
40 BINARY_POWER # Exponentiation of two topmost values is performed and
# substituted with the result
41 INPLACE_ADD # Two topmost values are added and substituted with the sum
42 STORE_FAST 3 (return_value) # Sum of the addition is stored in variable <return_value>

28 45 LOAD_FAST 2 (counter) # Value of variable <counter> is pushed to stack
48 LOAD_CONST 1 (1) # Constant of 1 is pushed to stack
51 INPLACE_ADD # Two topmost values are added and substituted with the sum
52 STORE_FAST 2 (counter) # Sum is stored in the variable <counter>
55 JUMP_ABSOLUTE 15 # Code execution jumps to instruction no 15 (the beginning of the loop)

29 >> 58 LOAD_FAST 3 (return_value) # The value of variable <return_value> is pushed to stack
61 RETURN_VALUE # Return top of the stack to the function caller

In the Python VM the state consists of:

* Program counter (PC), the number of currently executed instruction
* The stack and most importantly top of stack (TOS)
* Constants extracted from source (co_consts)
* Variables names (co_names)
* Variables values (co_varnames)
* There are *no* registers!

Executing the function with arguments exponent=2 and numbers=3 will result in return value of 14, the arguments are already placed in the co_varnames array by the calling function. Also the constants used in the code are present, so you may assume following state in the Python interpreter just before entering the function body:

-1. stack = []; co_varnames = [2, 3]; co_consts[?, 1, 0]

The steps that Python VM takes to get to the results are following:

0. LOAD_CONST 1: stack = [1]
3. STORE_FAST 2: stack = []; co_varnames = [2, 3, 1]
6. LOAD_CONST 2: stack = [0];
9. STORE_FAST 3: stack = []; co_varnames = [2, 3, 1, 0]
12. SETUP_LOOP 43: stack = []; loop is set up, counter is 1

Here we enter loop body for the first time

15. LOAD_FAST 2: stack = [1]
18. LOAD_FAST 1: stack = [1, 3]
21. COMPARE_OP 4: stack = [False]
24. POP_JUMP_IF_FALSE 31: stack = []; jump to instruction 31
31. LOAD_FAST 3: stack = [0];
34. LOAD_FAST 2: stack = [0, 1];
37. LOAD_FAST 0: stack = [0, 1, 2];
40. BINARY_POWER: stack = [0, 1]
41. INPLACE_ADD: stack = [1]
42. STORE_FAST 3: stack = []; co_varnames = [2, 3, 1, 1]
45. LOAD_FAST 3: stack = [1];
48. LOAD_CONST 1: stack = [1, 1];
51. INPLACE_ADD: stack = [2]
52. STORE_FAST 2: stack = []; co_varnames = [2, 3, 2, 1]
53. JUMP_ABSOLUTE 15: jump to instruction no 15, counter is 2

Here we enter loop body for the second time

15. LOAD_FAST 2: stack = [2]
18. LOAD_FAST 1: stack = [2, 3]
21. COMPARE_OP: stack = [False]
24. POP_JUMP_IF_FALSE 31: stack = []; jump to instruction 31
31. LOAD_FAST 3: stack = [1]; here we have only 1**1
34. LOAD_FAST 2: stack = [1, 2];
37. LOAD_FAST 0: stack = [1, 2, 2];
40. BINARY_POWER: stack = [1, 4]
41. INPLACE_ADD: stack = [5]; here we already have 1**2 + 2**2
42. STORE_FAST 3: stack = []; co_varnames = [2, 3, 2, 5]
45. LOAD_FAST 3: stack = [2];
48. LOAD_CONST 1: stack = [2, 1];
51. INPLACE_ADD: stack = [3]
52. STORE_FAST 2: stack = []; co_varnames = [2, 3, 3, 5]
53. JUMP_ABSOLUTE 15: jump to instruction no 15, counter is 3

Here we enter the loop body third time

15. LOAD_FAST 2: stack = [3]
18. LOAD_FAST 1: stack = [3, 3]
21. COMPARE_OP: stack = [False]
24. POP_JUMP_IF_FALSE 31: stack = []; jump to instruction 31
31. LOAD_FAST 3: stack = [5]
34. LOAD_FAST 2: stack = [5, 3];
37. LOAD_FAST 0: stack = [5, 3, 2];
40. BINARY_POWER: stack = [5, 9]
41. INPLACE_ADD: stack = [14]; here we have 1**2 + 2**2 + 3**2
42. STORE_FAST: stack = []; co_varnames = [2, 3, 3, 14]
45. LOAD_FAST 3: stack = [3];
48. LOAD_CONST 1: stack = [3, 1];
51. INPLACE_ADD: stack = [4]
52. STORE_FAST 2: stack = []; co_varnames = [2, 3, 4, 14]
53. JUMP_ABSOLUTE 15: jump to instruction no 15, counter is 4

Here we enter the loop body fourth (!!!) time

15. LOAD_FAST 2; stack = [4]
18. LOAD_FAST 1; stack = [4, 3]
21. COMPARE_OP 4; stack = [True]
24. POP_JUMP_IF_FALSE 31; stack = []; but the condition does not hold anymore so we jump out of the loop
27. BREAK_LOOP; break out of the loop
58. LOAD_FAST 3; stack = [14]
61. RETURN_VALUE; return 14 to caller

==Assignment steps==

# Select one of the Fibonacci code examples below.
# Use <code>from dis import dis</code> and <code>dis(function_name_goes_here)</code> to disassemble the function to opcodes.
# Comment the stack machine instructions as shown above (3p).
# Invoke the Fibonacci number calculation function with n=2, follow the instructions and elaborate after each instruction executed a) the stack contents b) co_varnames contents c) co_names contents d) what happened as shown above. Note that certain code blocks will be executed repeatedly, which means you'll have more than '''30 instructions executed''' (2p).

Fibonacci with iterators:

<pre>
def fib(n):
a,b = 1,1
for i in range(n-1):
a,b = b,a+b
return a
</pre>

Fibonacci with recursion:

def fib(n):
if n==1 or n==2:
return 1
return fib(n-1) + fib(n-2)

Fibonacci with infinite loop and breaks:

def fib3(n):
a,b,i = 1,1,0
while True:
i += 1
if i >= n: break
b,a = a+b,b
return a

Another variation:

def fib4(n):
a = 1
b = 1
i = 0
while True:
i += 1
if i >= n: break
s = a + b
a = b
b = s
return a

=Assignment: Investigating compilers=

Use what you learned in the [https://wiki.itcollege.ee/index.php/Getting_started_with_GCC Getting started with GCC] session.
See assignment steps below.
Everything you need to understand ARM instructions should be [http://aelmahmoudy.users.sourceforge.net/electronix/arm/chapter2.htm here].
Another good resource seems to be [http://www.davespace.co.uk/arm/introduction-to-arm/ Introduction to ARM] by David Thomas.
See page 14 of [http://infocenter.arm.com/help/topic/com.arm.doc.ihi0042e/IHI0042E_aapcs.pdf Procedure Call Standard for the ARM® Architecture] if you want to learn more about how function calls are implemented on ARM.
See [http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0204j/Cihfddaf.html here] for more information about branching instructions: B, BL, BX.
<Insert extemely useful link here yourself>

Deadline: 4. November

==Example==

If you don't have Ubuntu installed on your machine skip next step and use SSH to perform these steps remotely at <code>enos.itcollege.ee</code>.
Otherwise install ARM cross-compiler:

apt-get install gcc-arm-linux-gnueabi

Consider C snippet for calculating integer [https://en.wikipedia.org/wiki/Exponentiation exponentiation], place it in a file <code>power.c</code>:

int power(long base, long exponent) {
int counter;
int result = 1;
for (counter = 0; counter < exponent; counter++)
result *= base;
return result;
}

===Generating assembly===

Compile ARM assembly of the code snippet:

arm-linux-gnueabi-gcc -Os -S power.c -o power.s # Cross-compile ARM assembly file power.s from C source code file power.c
cat power.s # Dump the assembly file on terminal

The compiler should produce something similar to following:

.arch armv5t
.fpu softvfp
.eabi_attribute 20, 1
.eabi_attribute 21, 1
.eabi_attribute 23, 3
.eabi_attribute 24, 1
.eabi_attribute 25, 1
.eabi_attribute 26, 2
.eabi_attribute 30, 2
.eabi_attribute 34, 0
.eabi_attribute 18, 4
.file "power.c"
.text
.align 2
.global power
.type power, %function
power:
@ args = 0, pretend = 0, frame = 0
@ frame_needed = 0, uses_anonymous_args = 0
@ link register save eliminated.
cmp r1, #0
mov r2, #1
ble .L2
mov r3, #0
.L3:
add r3, r3, #1
cmp r3, r1
mul r2, r0, r2
bne .L3
.L2:
mov r0, r2
bx lr
.size power, .-power
.ident "GCC: (Ubuntu/Linaro 4.7.3-12ubuntu1) 4.7.3"
.section .note.GNU-stack,"",%progbits

===Commenting the assembly===

You can safely ignore the lines starting with dot, these are simply hints for the next stage of the compilation process.
Thus you're left only (!!!) 10 actual instructions. Here you can also see what kind of comments are expected from the submission:

power:
cmp r1, #0 /* Compare register r1 (second argument) contents against constant 0 */
mov r2, #1 /* Copy the constant 1 to register r2 */
ble .L2 /* Jump to label .L2 if the comparison was false */
mov r3, #0 /* Copy the constant 0 to register r3 */
.L3:
add r3, r3, #1 /* Perform r3 = r3 + 1 */
cmp r3, r1 /* Compare register r3 and r1 (second argument) */
mul r2, r0, r2 /* Perform r2 = r0 (first argument) * r2 */
bne .L3 /* If r3 and r1 were different jump to label .L3
.L2:
mov r0, r2 /* Copy register r2 contents to register r0 */
bx lr /* Jump back to caller */

===Analyzing the code===

Code analysis reveals that registers are mapped as following:

* <code>r0</code> - argument <code>base</code> and eventually return value
* <code>r1</code> - argument <code>exponent</code>
* <code>r2</code> - variable <code>result</code>
* <code>r3</code> - variable <code>counter</code>

We can also see how the <code>for</code> loop gets translated into assembly:

power:
cmp r1, #0
mov r2, #1
ble .L2
mov r3, #0
.L3:
add r3, r3, #1 <---+
cmp r3, r1 | 4 instructions are executed repeatedly
mul r2, r0, r2 | if exponent is greater than 0
bne .L3 -----------+
.L2:
mov r0, r2
bx lr

===Stepping through the instructions===

When we execute the function with for example arguments base=5 and exponent=3 following happens in the processor.
Note that this will essentially calculates 5 ^ 3 (5 to the power of 3) which is 125.
Following has been done manually to illustrate how much time does it take to execute the the function.

/* When processor enters the function body the arguments are already placed in registers r0=5 (base), r1=3 (exponent) */
cmp r1, #0 /* Compare exponent to 0 */
mov r2, #1 /* Place constant 1 in register r2,
this corresponds to result = 1 in C code */
ble .L2 /* Exponent was not less than 0, so no jump to L2
mov r3, #0 /* Place constant 0 in register r3,
this corresponds to variable counter */

add r3, r3, #1 /* Perform r3 = 0 + 1 which results in 1 being stored to r3
this corresponds to first invocation of counter++ in C code */
cmp r3, r1 /* Compare counter (1 in this case) to exponent (3), this will be used by bne instruction below */
mul r2, r0, r2 /* Perform r2 = r0 * r2 which results in 1 * 5 = 5 being placed in r2
this corresponds to first invocation of result *= base in C code */
bne .L3 /* The comparison resulted in counter being not equal to exponent, so we jump back to L3
this corresponds to first invocation of counter < exponent in C code */

add r3, r3, #1 /* Perform r3 = 1 + 1 which results in 2 being stored to r3
this corresponds to second invocation of counter++ in C code */
cmp r3, r1 /* Compare counter (2 in this case) to exponent (3), this will be used by bne instruction below */
mul r2, r0, r2 /* Perform r2 = r0 * r2 which results 5 * 5 = 25 being placed in r2
this corresponds to second invocation of result *= base in C code */
bne .L3 /* The comparison resulted in counter being not equal to exponent, so we jump back to L3
this corresponds to second invocation of counter < exponent in C code */

add r3, r3, #1 /* Perform r3 = 2 + 1 which results in 3 being stored to r3
this corresponds to third invocation of counter++ in C code */
cmp r3, r1 /* Compare counter (3 in this case) to exponent (3), this will be used by bne instruction below */
mul r2, r0, r2 /* Perform r2 = r0 * r2 which results 25 * 5 = 125 being placed in r2
this corresponds to third invocation of result *= base in C code */
bne .L3 /* The comparison resulted in counter being equal to exponent, so we DO NOT jump back to L3 */

mov r0, r2 /* Copy register r2 contents (125) to register r0 */
bx lr /* Jump back to caller */
/* Function returns with 125 placed in r0 this is where caller function should expect the return value */
/* The other registers will still hold whatever values were left there: r1 = 3, r2 = 125, r3 = 3 */

===ARM registers===

If you get lost with the ARM register naming conventions use following as a guide.

ARM7 has 16x 32-bit registers:

r0 (a1) - Argument/result/scratch register, this is where first function argument is usually placed
r1 (a2) - Argument/result/scratch register, this is where second function argument is placed
r2 (a3) - Argument/scratch register 3
r3 (a4) - Argument/scratch register 4
r4 (v1) - Variable register 1
r5 (v2) - Variable register 2
r6 (v3) - Variable register 3
r7 (v4) - Variable register 4
r8 (v5) - Variable register 5
r9 (v6) - Variable register 6
r10 (v7) - Variable register 7
r11 (fp) - Frame pointer, variable register 8
r12 (ip) - Intra-procedure call scratch register
r13 (sp) - Stack pointer
r14 (lr) - Link register (to which memory address currently
executing function should return to?)
r15 (pc) - Program counter (what is the memory address of instruction
^ that we are going to execute next?)
|
+- These are simply aliases for the numbered registers and
can be used interchangeably.

==Assignment steps==

# Select one of the Fibonacci calculation examples below and use ARM cross compiler as shown above to generate the assembly corresponding to the C source code (1p).
# Remove the compiler hints (lines starting with dot), this should leave you less than 20 instructions. If it's more than that try different optimization flags. Analyze and comment the assembly as shown above (1p).
# Use n=3 as argument and follow the instructions, what values are left in the registers after the function finishes (2p)?
# Optional/extra: Elaborate step by step what happens in the processor: what instruction is being executed and what values are left in registers after instruction finishes? (1p)
# Optional/extra: Recompile with different optimization levels: <code>-Os</code>, <code>-O0</code>, <code>-O1</code>, <code>-O2</code> and <code>-O3</code>. What differences did you notice? (1p)
# Optional/extra: Take a guess which one of the Fibonacci calculation functions below is the slowest? Which one is the fastest? Why? (1p)
# Send your conclusions as e-mail attachment to Lauri, attach the commented assembly, make sure you '''use the address supplied above with the course code''', otherwise your mail is not searchable in my mailbox.

Fibonacci calculation using <code>for</code>-loop:

int fib(n) {
int a = 1;
int b = 1;
int i;
for (i = 0; i < n; i++) {
int s = a + b;
a = b;
b = s;
}
return a;
}

Fibonacci calculation using recursion:

int fib2(n) {
if (n == 1 || n== 2) {
return 1;
} else {
return fib(n-1) + fib(n-2);
}
}

Fibonacci calculation using <code>while</code>-loop:

int fib4(n) {
int a = 1;
int b = 1;
int i = 0;
while(1) {
i += 1;
if (i >= n) { break; }
int s = a + b;
a = b;
b = s;
}
return a;
}

=Assignment: Investigating microcontrollers=

In this assignment we use Arduino to implement traffic lights for [http://www.nobleled.com/uploads/110833/100_101.jpg crossroads].
If you don't care much about doing this assignment hands on, you can give a try [https://123d.circuits.io/ online].

==Assignment steps==

* Install Arduino IDE on your personal machine, on Windows/Mac check out [https://www.arduino.cc/ Arduino homepage] for instructions, on Ubuntu <code>apt-get install arduino</code> should suffice. You can also use school computers, Ubuntu has Arduino preinstalled.
* From Arduino IDE menu open up File -> Examples -> 01. Basic -> Blink
* In Arduino IDE menu Tools -> Board -> Arduino Mega2560
* In Arduino IDE menu Tools -> Serial port -> Select what makes sense
* On Ubuntu you may have to add yourself to the dialout group before you can access the serial ports. Use the command <code>sudo gpasswd -a $USER dialout</code>, log out and log in again to your PC.
* Press the second button in the toolbar to upload the code, make sure the changes take effect on the board. You should see on-board LED blinking.
* Connect some LED-s to the board. '''MAKE SURE YOU USE RESISTORS TO PROTECT LED-s AND THE BOARD'''
* Implement traffic light cycle using <code>digitalWrite</code> and <code>delay</code> in the <code>loop</code> function (3p)
* Use interrupts to read button presses, see example below. Pressing the button should toggle the LED now (1p)
* Extra: Use [https://www.arduino.cc/en/Reference/AnalogWrite PWM] to implement smoother blinking (1p)
* Extra: Use [http://lauri.vosandi.com/arduino/lcd1602-key-shield.html LCD1602] shield to display countdown (1p)
* Use [https://www.arduino.cc/en/Reference/Serial serial] interface to send messages to your PC.
* You can find useful code snippets for Robotics club equipment [http://lauri.vosandi.com/arduino here]

==Code example: reading button press with interrupts==

Set up a push button as shown below:

[[File:Arduino-pushbutton_bb.png|500px]]

Insert following code to Arduino IDE and upload it to Arduino, verify that it works:

int led = 13;
int button = 2;
int flag = LOW;

void setup() {
pinMode(led, OUTPUT); // Set up pin 13 as digital output
pinMode(button, INPUT); // Set up pin 9 as digital input
digitalWrite(button, HIGH); // Turn in pull-up resistor

// Associate interrupt handler with an event
attachInterrupt(digitalPinToInterrupt(button), onButtonPressed, FALLING);
}

void onButtonPressed() {
// Keep this as short as possible
flag = HIGH;
}

void loop() {
// Do something useful or let processor sleep here
if (flag) {
digitalWrite(led, HIGH);
delay(2000);
flag = LOW;
}

digitalWrite(led, LOW);
delay(50);
}

==Code example: Cycling through different traffic light states==

Add LED-s to the design:

[[File:Traffic-lights_bb.png|500px]]

Use following as hint to implement cycling through traffic light states:

// Define pin numbers
int car_green = 5;
int car_yellow = 6;
int car_red = 7;

// For LED-s we're sinking the 5V voltage, hence LED is turned on when voltage on the pin is LOW
int on = LOW;
int off = HIGH;

void setup() {
pinMode(car_green, OUTPUT);
pinMode(car_yellow, OUTPUT);
pinMode(car_red, OUTPUT);
digitalWrite(cars_yellow, off);
Serial.begin(9600);
}

void loop() {
Serial.println("Cars green, pedestrians red for 5 seconds");
digitalWrite(cars_red, off);
digitalWrite(cars_green, on);
delay(5000);

Serial.println("Green for cars is blinking 5 seconds");
for(int j = 0; j < 10; j++) {
digitalWrite(cars_green, j % 2 == 0);
delay(500);
}

Serial.println("Cars red, pedestrians green for 5 seconds");
digitalWrite(cars_green, off);
digitalWrite(cars_red, on);
delay(5000);
}

==Skeleton of the final submission==

The real traffic light has of course a little bit more states:

1. Cars green, pedestrians red for 10 seconds
2. Cars green **blinking**, pedestrians red for 2 seconds
3. Cars red, pedestrians green for 10 seconds
4. Cars red, pedestrians green **blinking** for 2 seconds
5. Cars yellow, pedestrians red for 2 seconds

So your final code will look something like this:

// Define pin numbers here

// Initially the flag is low
int pedestrian_requested_crossing = LOW;

void setup() {
// Initialize necessary pins as digital outputs
// Reset pins with digitalWrite

// Initialize button pin as digital input
// Enable pull-up resistor on button pin
// Associate button interrupt handler function (onButtonPressed) below with the event on the button

}

void onButtonPressed() {
// Here set pedestrian_requested_crossing flag to HIGH
// Don't do anything else here!
}

void loop() {
Serial.println("Cars green, pedestrians red for 5 seconds");
digitalWrite(cars_red, off);
digitalWrite(cars_green, on);
// Set pedestrian lights here
delay(5000);

if (pedestrian_requested_crossing) {

Serial.println("Green for cars is blinking 5 seconds");
for(int j = 0; j < 10; j++) {
digitalWrite(cars_green, j % 2 == 0);
delay(500);
}

Serial.println("Cars red, pedestrians green for 5 seconds");
digitalWrite(cars_green, off);
digitalWrite(cars_red, on);
// Set pedestrian lights here
delay(5000);

// Add another state here

// And another state here

// Reset flag here
}
}

=Assignment: Adders with NAND gates=

In this assignment we use chips to build an adder. Get max points (4p) by wiring up half adder and double your points (8p) if you can make full adder work as well :)

[[File:53-7400n-detailed.png]]

Each SN74HC03N chip contains four NAND gates arranged like this, observe the pit on the left. VCC corresponds to 5V power supply and GND corresponds to ground or 0V.

==Half adder==

Each [http://www.ti.com/lit/gpn/sn74hc03 SN74HC03] contains 4 NAND gates.
Use breadboard to wire up half adder with 7400 chips (4p):

[[File:Half-adder_bb.png|700px]]

The truth table for half adder:

A | B | Cout | Sum | Human readable (how many bits are high?)
-----+-----+------+------+-------------------------------------------
0 | 0 | 0 | 0 | 0
-----+-----+------+------+-------------------------------------------
0 | 1 | 0 | 1 | 1
-----+-----+------+------+-------------------------------------------
1 | 0 | 0 | 1 | 1
-----+-----+------+------+-------------------------------------------
1 | 1 | 1 | 0 | 2

==Full adder==

You can double your points if you manage to wire up a full adder (+4p)

[[File:Nand-full-adder.png]]

On a breadboard it looks a bit messy, but if you pay attention to gate numbering as shown above it should make your life significantly easier.
The gates 1, 2, 3, 4 are placed in the leftmost chip; 5, 6, 7, 8 are placed in the middle one and gate 9 is the only one in the rightmost chip:

[[File:Full-adder_bb.png|700px]]

A | B | Cin | Cout | Sum | Human readable (how many bits are high?)
-----+-----+-----+------+------+-------------------------------------------
0 | 0 | 0 | 0 | 0 | 0
-----+-----+-----+------+------+-------------------------------------------
0 | 0 | 1 | 0 | 1 | 1
-----+-----+-----+------+------+-------------------------------------------
0 | 1 | 0 | 0 | 1 | 1
-----+-----+-----+------+------+-------------------------------------------
0 | 1 | 1 | 1 | 0 | 2
-----+-----+-----+------+------+-------------------------------------------
1 | 0 | 0 | 0 | 1 | 1
-----+-----+-----+------+------+-------------------------------------------
1 | 0 | 1 | 1 | 0 | 2
-----+-----+-----+------+------+-------------------------------------------
1 | 1 | 0 | 1 | 0 | 2
-----+-----+-----+------+------+-------------------------------------------
1 | 1 | 1 | 1 | 1 | 3

==Unittest==

Use following code snippet on Arduino to test the circuit, it will shuffle through all the possible inputs and test whether the expected output is on the output pins.
If you see <code>sum</code> or <code>cout</code> outputs giving 0 all the time it's likely you have resistors of too low resistance in the circuit which is draining all the voltage on the NAND gate output pins.

int PIN_A = 2;
int PIN_B = 3;
int PIN_CIN = 4;
int PIN_SUM = 5;
int PIN_COUT = 6;

void setup() {
// Set up serial
Serial.begin(9600);

// Set up operands
pinMode(PIN_A, OUTPUT);
pinMode(PIN_B, OUTPUT);
pinMode(PIN_CIN, OUTPUT);
digitalWrite(PIN_A, HIGH);
digitalWrite(PIN_B, HIGH);
digitalWrite(PIN_CIN, HIGH);

// Set up measurement pins
pinMode(PIN_SUM, INPUT);
pinMode(PIN_COUT, INPUT);
digitalWrite(PIN_SUM, HIGH); // Enable pull-up resistor
digitalWrite(PIN_COUT, HIGH); // Enable pull-up resistor
}

void test(int a, int b, int cin) {
int cout = a && b || a && cin || b && cin;
int sum = a ^ b ^ cin;

digitalWrite(PIN_A, a);
digitalWrite(PIN_B, b);
digitalWrite(PIN_CIN, cin);

Serial.print("Writing: a=");
Serial.print(a);
Serial.print(", b=");
Serial.print(b);
Serial.print(", cin=");
Serial.print(cin);
Serial.print(" Expecting: sum=");
Serial.print(sum);
Serial.print(", cout=");
Serial.print(cout);

int measured_sum = digitalRead(PIN_SUM);
int measured_cout = digitalRead(PIN_COUT);

Serial.print(" Got: sum=");
Serial.print(measured_sum);
Serial.print(" cout=");
Serial.print(measured_cout);

Serial.print(" Test:");
if (measured_sum != sum || measured_cout != cout) {
Serial.print(" FAIL");
} else {
Serial.print(" GOOD");
}
Serial.println();
delay(500);
}

void loop() {
Serial.println("Running test");
test(0, 0, 0);
test(0, 0, 1);
test(0, 1, 0);
test(0, 1, 1);
test(1, 0, 0);
test(1, 0, 1);
test(1, 1, 0);
test(1, 1, 1);
}

=Assignment: Debugging ALU design=

Bob had to ship the ALU design to the hardware manufacturer by yesterday. The project manager is angry about missed deadline. Bob still hasn't figured out why the ALU is not working properly. Help Bob by figuring out what's the problem.

If you're on Ubuntu install GHDL and GtkWave, otherwise simply use a school computer:

sudo add-apt-repository ppa:pgavin/ghdl
sudo apt-get update
sudo apt-get install ghdl gtkwave git

Clone the repository

git clone https://github.com/laurivosandi/vhdl-exercise

Use <code>make</code> to compile the components and run the testbench:

cd path/to/vhdl-exercise
make

Expected output of the testbench:

alu_testbench.vhd:77:9:@360ns:(report note): Finished testing addition operation of ALU
alu_testbench.vhd:106:9:@1us:(report note): Finished testing subtraction operation of ALU
alu_testbench.vhd:135:9:@1640ns:(report note): Finished testing NAND operation of ALU
alu_testbench.vhd:166:9:@2280ns:(report note): Finished testing NOR operation of ALU

However there are few bugs in <code>alu.vhd</code>, find the bugs and correct them. If this is your first experience with VHDL, take a look [http://lauri.vosandi.com/hdl/ here].

=Assignment: Publishing your work=

Deadline: 25. November

* Clean up your Git repositories and send the URL of a repository that you've actively worked on (for example the one from Java course) to Lauri, but before check the following:
** The repository should show changes you've made over at least few days.
** The repository has to contain only plaintext files unless there is a really good reason not to (eg. images).
** There has to be authorship information in the files.
** Add <code>.gitignore</code> file to your GitHub repositories to ignore temporary files, see [https://git-scm.com/docs/gitignore Git docs] for more details.
** Add [http://opensource.org/licenses LICENSE] file in the repository directory and commit the changes. LICENSE should answer to some important questions
*** Who is the copyright holder?
*** Under which conditions is redistribution permitted?
** Add nicely formatted README file, see [https://help.github.com/articles/markdown-basics/ Markdown] (online editor [http://dillinger.io here]) and [http://sphinx-doc.org/rest.html reStructuredText] for more details. README should answer to several silly questions:
*** What is the repository about?
*** Who made it?
*** How can the author be contacted? E-mail address, IRC chat channel on Freenode, Skype username?
*** How can the code be used? What hardware is necessary? How should the user wire the circuit to make it work? Add images if necessary.
*** What is the policy for including changes from third party developers?
* There will be more details here

=Extra points=

Here you can claim extra credit points for various tasks, this is mostly to improve the quality of wiki.itcollege.ee.
Once you have taken care of the task insert your name in the end of the line with corresponding date.

* Expand [[Getting started with Ubuntu#Installing in VirtualBox]] section with highlighted screenshots of VirtualBox. Points: 1p
* Create [[Claiming GitHub Student Developer Pack]] with screenshots how to add @itcollege.ee e-mail to your GitHub profile and claim [https://education.github.com/pack Student Developer Pack] Points: 2p