Courses

Computing involves processing information. In order to be processed, information must be represented in such a way that it can be manipulated by a machine ubiquitous in today’s society - the computer. **** The computer is a physical device that is based on binary digital logic. From this logic, physical components (hardware) such as memory and processors are designed. These components must fetch, execute and respond to given instructions (software). This course provides a foundation in the organization and operation of a digital electronic computer starting with the binary digital logic used to represent information and build hardware components. Then, upon this foundation will be built the skills necessary to solve programs through assembly language programs. High-level language algorithms will provide the blueprints for the assembly language solutions. Specifically, in successfully completing this course you will be able to: Describe how computers represent information and apply this knowledge in solving problems with solutions written in assembly language. Describe the basic organization of a computer system in terms of binary digital hardware components and apply this knowledge in solving problems with solutions written in assembly language. Describe how instructions are fetched and executed using the digital components and apply this knowledge in solving problems with solutions written in assembly language. Design and create assembly language programs that are solutions to problems expressed with algorithms that include high-level language concepts such as variables, data types, repetition, selection, and objects.

Discover how to rapidly build a robust portfolio of microservices using proven patterns and open source software in this 53-minute Devoxx conference talk. Explore essential topics for creating a solid foundation for dynamic and growing microservice architectures, including configuration services, microservice registration and discovery, circuit breakers for graceful degradation, load balancing, intelligent routing, asynchronous messaging, reactive services, events, and backpressure. Learn about service security, covering authentication, authorization, OAuth2, and attack defenses. Gain insights into logging, tracing, testing approaches, and migration patterns. Watch as the presenter demonstrates developing, securing, and effectively managing microservices using open source tools employed by Netflix to maintain global 24/7 movie streaming operations.

The Assembler language on z/OS or Mainframe Assembler Programming What you'll learn: Introduction to Assembler LanguageMemory ConceptsInstruction FormatsSymbols, Data Constants and StorageData Transfer and Logical OperationsBit ManipulationsBranchingJCL AspectsSubroutines, Linkage 24 Bit ModeAssembler Directives and Macros - LTORG, CSECT, DSECT , GET,PUTFile Handling - Flat and VSAM file We have conducted virtual instructor led training before. Same videos uploaded without filters.All the examples are covered practically.Topics list:Introduction to Assembler Language Basic Concept of Number System - Decimal and HexadecimalMemory ConceptsBigIndianData Representation -- Binary, EBCIDIC,Packed DecimalInstruction FormatsRegisters - PSW , GPRTypes of Instruction formatSymbols, Data Constants and StorageData Transfer and Logical OperationsBit ManipulationsBranchingJCL AspectsCompiler Options -- RENT,ALIGN Linkage PARM handling in ProgramSubroutines, Linkage 24 Bit ModeAssembler Directives and Macros - LTORG, CSECT, DSECT , GET,PUTFile Handling - Flat and VSAM file Assembler language is a symbolic programming language that can be used to code instructions instead of coding in machine language. The Assembler language is the symbolic programming language that is closest to the machine language in form and content, and therefore is an excellent candidate for writing programs in which:You need control of your program, down to the byte or bit level.You must write subroutines1 for functions that are not provided by other symbolic programming languages, such as COBOL, FORTRAN, or PL/I.Assembler language is made up of statements that represent either instructions or comments. The instruction statements are the working part of the language, and they are divided into the following three groups: A machine instruction is the symbolic representation of a machine language instruction of instruction sets, such as:IBM® Enterprise Systems Architecture/390 (ESA/390)IBM z/Architecture®It is called a machine instruction because the assembler translates it into the machine language code that the computer can execute. An assembler instruction is a request to the assembler to do certain operations during the assembly of a source module; for example, defining data constants, reserving storage areas, and defining the end of the source module.A macro instruction or macro is a request to the assembler program to process a predefined sequence of instructions called a macro definition. From this definition, the assembler generates machine and assembler instructions, which it then processes as if they were part of the original input in the source module.The assembler produces a program listing containing information that was generated during the various phases of the assembly process.2 It is really a compiler for Assembler language programs. The assembler also produces information for other processors, such as a binder (or linker, for earlier releases of the operating system). Before the computer can execute your program, the object code (called an object deck or simply OBJ) has to be run through another process to resolve the addresses where instructions and data will be located. This process is called linkage-editing (or link-editing, for short) and is performed by the binder. The binder or linkage editor uses information in the object decks to combine them into load modules. At program fetch time, the load module produced by the binder is loaded into virtual storage. After the program is loaded, it can be run.

Learn to decipher x64 assembly language in this comprehensive conference talk from ACCU 2017. Explore the layers beneath high-level programming languages, focusing on 64-bit C++ programs. Discover how to interpret assembly code, understand common instructions, and relate them to source code. Gain insights into stack frame navigation, variable location, and debugging techniques. Examine real-world examples from Linux and Windows environments, compare different assembly dialects, and learn to use tools like Compiler Explorer. Equip yourself with essential skills for effective program analysis and debugging at the assembly level.

Explore the groundbreaking Keystone Engine, a next-generation assembler framework, in this 24-minute Black Hat conference talk. Delve into the world of multi-architecture, multi-platform assembler frameworks and discover how Keystone addresses the long-standing need for a comprehensive solution in the Reverse Engineering (RE) community. Learn about its support for various architectures including Arm, Arm64, Hexagon, Mips, PowerPC, Sparc, SystemZ, and X86, as well as its clean, intuitive API and language bindings. Understand the challenges in designing and implementing such a framework, and see how Keystone's thread-safe, open-source nature sets it apart. Gain insights into the potential applications of Keystone in security research and development, and witness demonstrations of advanced RE tools built using this powerful engine.

Explore essential assembler terminology in this fifth programming basics lesson. Learn about the assembler's role in converting text source files into executable programs. Discover key concepts like assembly source files, binary files, compilers, linkers, listing files, and symbol files. Gain a solid foundation for understanding the process of transforming source code into runnable programs. Access complementary text lessons, source code, and additional resources on the ChibiAkumas website to enhance your learning experience.

Dive into a comprehensive 58-minute crash course on (x86-64) GNU Assembler (GASM), designed to equip you with essential skills for writing your own operating system. Learn the fundamentals of assembly language programming specific to the x86-64 architecture, exploring key concepts and techniques used in low-level system development. Gain hands-on experience with GASM syntax, instruction sets, and best practices for efficient code writing. Perfect for aspiring OS developers and those interested in understanding the intricacies of computer architecture and system-level programming.

Explore the design principles behind the Go assembler in this 24-minute conference talk from GopherCon 2016. Delve into the historical context of assembly language, starting with the Apollo 11 Guidance Computer, and learn about the common structure of assemblers. Discover the evolution from Plan 9 assemblers to the Go 1.5 Assembler, examining new components and their implementation. Follow along with a practical example of initializing the 386 architecture, and gain insights into the testing and table-driven approach used in the Go assembler's development. Enhance your understanding of low-level programming concepts and the Go language's internal workings through this informative presentation by Rob Pike.

Explore essential assembler terminology in this comprehensive video lesson. Delve into key concepts like direction pointers, vector tables, indirection, jump and branch instructions, subroutines, self-modifying code, alignment, and logical operations. Gain a solid understanding of how the assembler transforms text source files into executable programs. Access accompanying text lessons, source code, and additional resources to enhance your learning experience and deepen your knowledge of assembly language programming across various CPU architectures.

Explore a conference talk on coinvariants, assembler K-theory, and scissors congruence delivered by Inna Zakharevich at the Centre International de Rencontres Mathématiques in Marseille, France. Delve into the intricate world of mathematics as the speaker covers topics such as scissors congruence, scissors congruence algebra, assembler K-theory, Steinberg modules, and K-groups. Gain geometric intuition and learn how to compute scissors images. This hour-long presentation, part of the thematic meeting on "Chromatic Homotopy, K-Theory and Functors," offers valuable insights for mathematicians and researchers in related fields. Access this video and other talks by renowned mathematicians through CIRM's Audiovisual Mathematics Library, which features chapter markers, keywords, abstracts, bibliographies, and a multi-criteria search function for easy navigation and exploration of mathematical content.

Explore CPU-optimized data structures and advanced assembler techniques in this ACCU 2019 conference talk. Dive into the world of modern CPU instructions and specialized optimizations as the speaker tackles an educational problem: evaluating poker hands. Learn how to optimize data representation for high-performance solutions, surpassing typical implementations in languages like C++. Examine SIMD instructions and their performance benefits, along with the challenges of data manipulation. Investigate methods for efficiently testing straights, flushes, and full houses using x86-64 architecture features. Compare the custom solution's performance against optimized C++ code, and gain insights into advanced software optimization techniques for specific use cases.

This course provides an introduction to the z/Architecture Assembler language. The course is designed to develop the skills appropriate to write and/or maintain programs and routines written in z/Architecture Assembler language, and to maintain programs written for earlier versions of the architecture.Second level of this course will be available late September or early October, 2023. We're almost done!

Welcome to z/Architecture Assembler Language Part 2: Machine Instructions, the second course in the three part series for the z/Architecture Assembler Language Specialization. This course teaches z/Architecture machine instructions and Assembler language instructions that a programmer needs to write Assembler application programs and utilizes hands-on labs. By the end of this course, you will be able to: - Code z/Architecture machine instructions that: - Copy data to/from registers - Perform signed binary integer arithmetic operations - Compare signed binary integers - Perform conditional or unconditional branching - Move or compare characters - Operate on bits - Perform decimal arithmetic operations - List the Assembler Jump and Branch extended mnemonics - Understand the role of the PSW condition code - Understand the role of the PSW program mask - Format a decimal number for displaying or printing This is an intermediate course, intended for learners with a background in computer science and professionals that require Assembler knowledge on IBM Z. Before taking this course, you should have completed the first course in the three part series for the z/Architecture Assembler Language Specialization, z/Architecture Assembler Language Part 1: The Basics. To complete the labs, you need basic knowledge of TSO/ISPF and JCL. In particular, you should know how to: - Logon to TSO - Edit a file with the ISPF editor - Submit a job - View a job's output in SDSF You can learn about TSO/ISPF in the course Getting Started on Mainframe with z/OS Commands and Panels.

This course teaches z/Architecture machine instructions and Assembler language instructions that a programmer needs to write Assembler application programs.

Learn how to assemble the Koch v1.1 robot in this 20-minute tutorial video recorded by Jess Moss in July 2024. Explore the modifications made to Alexander Koch's original Koch v1.0 design, which reduce costs and simplify assembly while maintaining full compatibility. Access the bill of materials and CAD models for the Koch v1.1 on GitHub to order parts and customize the robot. Discover the open-source origins of the project and the contributions of Alexander Koch. Connect with the LeRobot team at HuggingFace through their GitHub repository, Twitter account, and Discord community for further support and engagement in robotics development.

Explore the extension of GNU assembler to Synthesize CFI (SCFI) for hand-written assembly in this 48-minute conference talk from the Linux Plumbers Conference. Learn about the new command line option "--scfi[=all,none]" that allows users to invoke GAS' SCFI machinery. Discover the restrictions on hand-written assembly and the progress of the project, with x86_64 as the first target. Gain insights into potential future developments, including the "--scfi=inline" option for handling inline assembly. Engage in a discussion about the usefulness of this feature for the Linux kernel and explore possible extensions needed to accommodate the kernel's use of hand-written and inline assembly.

Explore the architectural transformation of Rome under Emperor Augustus in this 75-minute lecture from Yale University's Roman Architecture course. Discover how Augustus fulfilled his claim of turning Rome from a city of brick to a city of marble through the exploitation of new quarries. Examine the transition from the Roman Republic to the Principate, analyzing key structures like the Forum of Julius Caesar and the Forum of Augustus. Learn about Caesar's efforts to connect himself to Venus Genetrix and Augustus' incorporation of Greek elements to associate his reign with Athens' Golden Age. Delve into the significance of the Ara Pacis Augustae, a monument symbolizing Augustus' diplomatic triumphs and imperial power. The lecture also covers the historical impact of these architectural changes, from ancient times to Mussolini's era and beyond.

Explore the critical intersection of medical ethics and jurisprudence in this insightful one-hour lecture delivered by Dr. Mukesh Yadav. Delve into the fundamental importance of technical competence in the medical profession and its ethical implications. Examine how the possession of essential knowledge and skills forms the core of professional integrity, and understand the societal impact of falsely professing expertise. Gain valuable perspectives on the ethical standards expected of physicians and how these principles are applied in legal contexts. Learn why technical competence is often omitted from discussions of professional ethics and its significance in entering the medical field. Enhance your understanding of the ethical foundations that underpin medical practice and their relevance in medical jurisprudence.

Learn how to incorporate Assembler code within an Arduino sketch in this informative tutorial. Explore the process of integrating time-critical or sensor-specific code written in Assembler, whether created by you or a third party. Begin with an introduction to Assembler and walk through both the Arduino sketch and Assembler code. Examine the accuracy of Assembler timing and observe a live demonstration with updates. Gain insights into how components work together behind the scenes, making it accessible even for beginners. While not expecting viewers to write full Assembler programs, the tutorial showcases how straightforward it can be to experiment with this low-level programming language in an Arduino environment.

Discover the power of community collaboration in this 40-minute Microsoft Build 2022 conference talk. Explore the concept of being a "super contributor" and learn how to unleash your unique talents within the Microsoft community. Understand the various forms of contributions, from training and speaking to bug fixing and mentoring. Confront common obstacles like imposter syndrome and time management challenges. Gain insights on overcoming these hurdles and reap the benefits of community involvement, including expanded knowledge, new friendships, and potential recognition as a Microsoft Most Valuable Professional (MVP). Embrace your origin story as a contributor and join a network of passionate technology enthusiasts working together to improve the greater good of the community.