Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1lTVeyw.
Graham Markall covers some of the common problems that can occur from using the IEEE754 floating-point arithmetic, and what to do to avoid them in practice. Filmed at qconlondon.com.
Graham Markall is an Applied Maths Developer at OpenGamma. He works on the OG-Maths library, which uses native code generation to provide an environment for developing fast and robust numerical methods from within Java. He completed a PhD at Imperial College London, where he developed a runtime compilation framework for implementing high-performance solvers for partial differential equations.
I am telling about basic c such as variable,constant,operators,decison making,loops,switch,break and continue,function,call by value ,call by reference and recursion.In this pdf i give some practice problems too.
A general coverage of the C language is presented. These slides are useful for students attending C courses at universities and other institutions as well as others following C tutorials or learning the language by themselves. Comments are welcome for creating better future.
Faculty of Eng. & Computer Sciences of IEU, Izmir-Turkey,
Assoc. Prof. Dr. S. Kondakci
I am telling about basic c such as variable,constant,operators,decison making,loops,switch,break and continue,function,call by value ,call by reference and recursion.In this pdf i give some practice problems too.
A general coverage of the C language is presented. These slides are useful for students attending C courses at universities and other institutions as well as others following C tutorials or learning the language by themselves. Comments are welcome for creating better future.
Faculty of Eng. & Computer Sciences of IEU, Izmir-Turkey,
Assoc. Prof. Dr. S. Kondakci
printf("%s from %c to Z, in %d minutes!\n", "printf", 'A', 45);Joel Porquet
Guest-lecture given at UC Davis during my interview day in May of 2018.
Description: Using the printf() function is one of the very first steps every beginner learns when taking a programming class. It is also one of the most ubiquitous functions in software programs, across the many languages that define it. But how many programmers actually know how this common function works behind the scenes?
During this lecture, I will trace a brief history of printf(), delve into the nuts of bolts of a simple implementation through interactive coding, and branch out into interesting facts related to this function.
Audio Version available in YouTube Link : www.youtube.com/Aksharam
subscribe the channel
Computer Architecture and Organization
V semester
Anna University
By
Babu M, Assistant Professor
Department of ECE
RMK College of Engineering and Technology
Chennai
printf("%s from %c to Z, in %d minutes!\n", "printf", 'A', 45);Joel Porquet
Guest-lecture given at UC Davis during my interview day in May of 2018.
Description: Using the printf() function is one of the very first steps every beginner learns when taking a programming class. It is also one of the most ubiquitous functions in software programs, across the many languages that define it. But how many programmers actually know how this common function works behind the scenes?
During this lecture, I will trace a brief history of printf(), delve into the nuts of bolts of a simple implementation through interactive coding, and branch out into interesting facts related to this function.
Audio Version available in YouTube Link : www.youtube.com/Aksharam
subscribe the channel
Computer Architecture and Organization
V semester
Anna University
By
Babu M, Assistant Professor
Department of ECE
RMK College of Engineering and Technology
Chennai
Profitable growth via adjacency - Guest lecture on Zook by Peter SpungPeter Spung
A guest lecture on Chris Zook's framework for profitable business growth via market adjacency moves by Peter Spung at the Graziadio b-school. For more, see Peter's blog: biztechalign.blog
Tree-like data relationships are common, but working with trees in SQL usually requires awkward recursive queries. This talk describes alternative solutions in SQL, including:
- Adjacency List
- Path Enumeration
- Nested Sets
- Closure Table
Code examples will show using these designs in PHP, and offer guidelines for choosing one design over another.
error 2.pdf101316, 6(46 PM01_errorPage 1 of 5http.docxSALU18
error 2.pdf
10/13/16, 6(46 PM01_error
Page 1 of 5http://localhost:8888/nbconvert/html/group/01_error.ipynb?download=false
In [ ]: %matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
import sys
Error Definitions
Following is an example for the concept of absolute error, relative error and decimal precision:
We shall test the approximation to common mathematical constant, . Compute the absolute and relative
errors along with the decimal precision if we take the approximate value of .
In [ ]: # We can use the formulas you derieved above to calculate the actual n
umbers
absolute_error = np.abs(np.exp(1) - 2.718)
relative_error = absolute_error/np.exp(1)
print "The absolute error is "+str(absolute_error)
print "The relative error is "+str(relative_error)
Machine epsilon is a very important concept in floating point error. The value, even though miniscule, can
easily compund over a period to cause huge problems.
Below we see a problem demonstating how easily machine error can creep into a simple piece of code:
In [ ]: a = 4.0/3.0
b = a - 1.0
c = 3*b
eps = 1 - c
print 'Value of a is ' +str(a)
print 'Value of b is ' +str(b)
print 'Value of c is ' +str(c)
print 'Value of epsilon is ' +str(eps)
Ideally eps should be 0, but instead we see the machine epsilon and while the value is small it can lead to
issues.
e
e = 2.718
10/13/16, 6(46 PM01_error
Page 2 of 5http://localhost:8888/nbconvert/html/group/01_error.ipynb?download=false
In [ ]: print "The progression of error:"
for i in range(1,20):
print str(abs((10**i)*c - (10**i)))
The largest floating point number
The formula for obtaining the number is shown below, instead of calculating the value we can use the
system library to find this value.
In [ ]: maximum = (2.0-eps)*2.0**1023
print sys.float_info.max
print 'Value of maximum is ' +str(maximum)
The smallest floating point number
The formula for obtaining the number is shown below. Similarly the value can be found using the system
library to find this value.
In [ ]: minimum = eps*2.0**(-1022)
print sys.float_info.min
print sys.float_info.min*sys.float_info.epsilon
print 'Value of minimum is ' +str(minimum)
As we try to compute a number bigger than the aforementioned, largest floating point number we see weird
errors. The computer assigns infinity to these values.
In [ ]: overflow = maximum*10.0
print 'Value of overflow is ' +str(overflow)
As we try to compute a number smaller than the aforementioned smallest floating point number we see that
the computer assigns it the value 0. We actually lose precision in this case.
10/13/16, 6(46 PM01_error
Page 3 of 5http://localhost:8888/nbconvert/html/group/01_error.ipynb?download=false
In [1]: underflow = minimum/2.0
print 'Value of underflow is ' +str(underflow)
Truncation error is a very common form of error you will keep seing in the area of Numerical
Analysis/Computing.
Here we will look at the classic Calculus example of the approximation near 0. We c ...
We have finished studying the patterns of 64-bit errors and the last thing we will speak about, concerning these errors, is in what ways they may occur in programs.
Robotics/.DS_Store
__MACOSX/Robotics/._.DS_Store
Robotics/__pycache__/finch.cpython-34.pyc
__MACOSX/Robotics/__pycache__/._finch.cpython-34.pyc
Robotics/__pycache__/finch.cpython-35.pyc
__MACOSX/Robotics/__pycache__/._finch.cpython-35.pyc
Robotics/__pycache__/finchconnection.cpython-34.pyc
__MACOSX/Robotics/__pycache__/._finchconnection.cpython-34.pyc
Robotics/__pycache__/finchconnection.cpython-35.pyc
__MACOSX/Robotics/__pycache__/._finchconnection.cpython-35.pyc
__MACOSX/Robotics/.___pycache__
Robotics/Finch Python API Description.pdf
Finch Python Package Description
Description of Files
finch.py – Contains the Finch API functions for controlling Finch
finchconnection.py – Contains low level functions for sending and receiving data over USB, used by
finch.py
hidapi32/64.dll, libhidapi.dylib, libhidapi32/64.so, libhidapipi.so – compiled C libraries used by
finchconnection.py to scan for USB devices (specifically, the Finch) and open a connection. dll files are
for Windows, dylib is for OSX, and so is for Linux.
accelerationExampleOne.py, accelerationExampleTwo.py, dance.py, wanderer.py, alarm.py,
lapswimmer.py, musicexample.py, racedriver.py, tapExample.py, testfinchfunctions.py – Example
Python programs, open them for more information on what each one does.
notes.py – helper class used by musicexample.py to simplify playing lots of notes on the Finch buzzer.
Finch API
General
close – closes the connection to the Finch
Usage: call this when your program is exiting to cleanly close the Finch connection. This will shut off the
motors and then send the Finch back to idle mode (color changing)
halt – convenience function to shut off the Finch LED and finch motors
Usage: call whenever you wish the Finch to stop moving and turn off its LED with one function call. Will
not shut off the buzzer.
Outputs
led – controls the Finch beak color
Usage: hex triplet string: finch.led(‘#0000FF’) or 0-255 RGB values: finch.led(0, 0, 255). The first value
indicates the red intensity, second is green, third is blue.
wheels – Controls the power sent to the left and right wheels
Usage: values must range from -1.0 to 1.0 for each wheel, use left=right=0.0 to stop. Examples:
finch.wheels(1.0, 1.0) # full forward
finch.wheels(-1.0, -1.0) # full reverse
finch.wheels(0.7, -0.3) # 70% forward on left wheel, 30% reverse on right wheel
buzzer – outputs sound over the Finch buzzer
Usage: pass two parameters, duration in seconds followed by frequency in Hertz. Frequencies between
20 and 20,000 are audible. Example (plays 440 Hz note for ½ second): finch.buzzer(0.5, 440).
Note that this function does not delay program execution; to delay, use buzzer_with_delay. If two
buzzer functions are called one after the other, only the second will play. For example, the following will
only play a single 880 Hz note:
finch.buzzer(0.5, 220)
finch.buzzer(0.5, 880)
buzzer_with_delay – outputs sound over the ...
Switch Control and Time Delay
1. LEDs and switches
2. Keypad and LEDs
3. Keypad and 8-segment LED C language and Assembly Code for Freescale MC9S08AW60
Floating point basicsThe core idea of floating-point representatio.pdfinfo235816
Floating point basics
The core idea of floating-point representations (as opposed to fixed point representations as used
by, say, ints), is that a number x is written as m*be where m is a mantissa or fractional part, b is a
base, and e is an exponent. On modern computers the base is almost always 2, and for most
floating-point representations the mantissa will be scaled to be between 1 and b. This is done by
adjusting the exponent, e.g.
1 = 1*20
2 = 1*21
0.375 = 1.5*2-2
etc.
Iam writing a program that does some floating addition that uses bit patterns with shifts applied
to the mantissa and such to obtain the sum of the two floating point numbers. Logically and on
paper I can get this to compute the correct sum.
Code:
#include
#include
#include
#include
int isNegative (float f)
{
unsigned int* iptr = (unsigned int*)&f;
return ( ((*iptr) & 0x80000000) ? 1:0);
}
unsigned char getExponent (float f)
{
unsigned int* iptr = (unsigned int*)&f;
return (((*iptr >> 23) & 0xff) - 127);
}
unsigned int getMantissa (float f)
{
unsigned int* iptr = (unsigned int*)&f;
if( *iptr == 0 ) return 0;
return ((*iptr & 0xFFFFFF) | 0x800000 );
}
float sum (float left, float right)
{
unsigned int littleMan;
unsigned int bigMan;
unsigned char littleE;
unsigned char bigE;
unsigned char lexp = getExponent(left);
unsigned char rexp = getExponent(right);
int Dexponent;
if (lexp > rexp)
{
bigE = lexp;
bigMan = getMantissa(left);
littleE = rexp;
littleMan = getMantissa(right);
}
else
{
bigE = rexp;
bigMan = getMantissa(right);
littleE = lexp;
littleMan = getMantissa(left);
}
printf(\"little: %x %x\ \", littleE, littleMan);
printf(\"big: %x %x\ \", bigE, bigMan);
void shift( unsigned int *valToShift, int bitsToShift )
{
// Masks is used to mask out bits to check for a \"sticky\" bit.
static unsigned masks[24] =
{
0, 1, 3, 7, 0xf, 0x1f, 0x3f, 0x7f,
0xff, 0x1ff, 0x3ff, 0x7ff, 0xfff, 0x1fff, 0x3fff, 0x7fff,
0xffff, 0x1ffff, 0x3ffff, 0x7ffff, 0xfffff, 0x1fffff, 0x3fffff, 0x7fffff
};
// HOmasks - masks out the H.O. bit of the value masked by the masks entry.
static unsigned HOmasks[24] =
{
0,
1, 2, 4, 0x8, 0x10, 0x20, 0x40, 0x80,
0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000,
0x10000, 0x20000, 0x40000, 0x80000, 0x100000, 0x200000, 0x400000
};
// shiftedOut- Holds the value that will be shifted out of a mantissa
// during the denormalization operation (used to round a denormalized value).
int shiftedOut;
assert( bitsToShift <= 23 );
// Grabs the bits we\'re going to shift out (so we can determine
// how to round this value after the shift).
shiftedOut = *valToShift & masks[ bitsToShift ];
// Shift the value to the right the specified number of bits:
*valToShift = *valToShift >> bitsToShift;
// If necessary, round the value:
if( shiftedOut > HOmasks[ bitsToShift ] )
{
// If the bits we shifted out are greater than 1/2 the L.O. bit, then
// round the value up by one.
*valToShift = *valToShift + 1;
}
else if( shiftedOut == HOmasks[ bitsToShift ] )
{
// If the bits we shif.
IEEE-754 standard format to handle Floating-Point calculations in RISC-V CPUs...zeeshanshanzy009
The IEEE Standard for Floating-Point Arithmetic (IEEE 754) is a technical standard for floating-point arithmetic established in 1985 by the Institute of Electrical and Electronics Engineers (IEEE). The standard addressed many problems found in the diverse floating-point implementations that made them difficult to use reliably and portable. RISC-V also uses the IEEE 754 standard.
High School level (years 9-10 in Australia, ages 14-16) introduction to programming course, based on the language Processing, includes class material, exercises, examples, and tests. Course ran for 2 terms in 2014. Feel free to use as is, borrow ideas, etc. 3rd class.
Streaming a Million Likes/Second: Real-Time Interactions on Live VideoC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/39NIjLV.
Akhilesh Gupta does a technical deep-dive into how Linkedin uses the Play/Akka Framework and a scalable distributed system to enable live interactions like likes/comments at massive scale at extremely low costs across multiple data centers. Filmed at qconlondon.com.
Akhilesh Gupta is the technical lead for LinkedIn's Real-time delivery infrastructure and LinkedIn Messaging. He has been working on the revamp of LinkedIn’s offerings to instant, real-time experiences. Before this, he was the head of engineering for the Ride Experience program at Uber Technologies in San Francisco.
Next Generation Client APIs in Envoy MobileC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2x0Fav8.
Jose Nino guides the audience through the journey of Mobile APIs at Lyft. He focuses on how the team has reaped the benefits of API generation to experiment with the network transport layer. He also discusses recent developments the team has made with Envoy Mobile and the roadmap ahead. Filmed at qconlondon.com.
Jose Nino works as a Software Engineer at Lyft.
Software Teams and Teamwork Trends Report Q1 2020C4Media
How do we cope with an environment that has been radically disrupted, where people are suddenly thrust into remote work in a chaotic state? What are the emerging good practices and new ideas that are shaping the way in which software development teams work? What can we do to make the workplace a more secure and diverse one while increasing the productivity of our teams? This report aims to assist technical leaders in making mid- to long-term decisions that will have a positive impact on their organisations and teams and help individual contributors find the practices, approaches, tools, techniques, and frameworks that can help them get a better experience at work - irrespective of where they are working from.
Understand the Trade-offs Using Compilers for Java ApplicationsC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2QCmmJ0.
Mark Stoodley examines some of the strengths and weaknesses of the different Java compilation technologies, if one was to apply them in isolation. Stoodley discusses how production JVMs are assembling a combination of these tools that work together to provide excellent performance across the large spectrum of applications written in Java and JVM based languages. Filmed at qconsf.com.
Mark Stoodley joined IBM Canada to build Java JIT compilers for production use and led the team that delivered AOT compilation in the IBM SDK for Java 6. He spent the last five years leading the effort to open source nearly 4.3 million lines of source code from the IBM J9 Java Virtual Machine to create the two open source projects Eclipse OMR and Eclipse OpenJ9, and now co-leads both projects.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2y2yPiS.
Colin McCabe talks about the ongoing effort to replace the use of Zookeeper in Kafka: why they want to do it and how it will work. He discusses the limitations they have found and how Kafka benefits both in terms of stability and scalability by bringing consensus in house. He talks about their progress, what work is remaining, and how contributors can help. Filmed at qconsf.com.
Colin McCabe is a Kafka committer at Confluent, working on the scalability and extensibility of Kafka. Previously, he worked on the Hadoop Distributed Filesystem and the Ceph Filesystem.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2SXXXiD.
Katharina Probst talks about what it means to act like an owner and why teams need ownership to be high-performing. When team members, regardless of whether they have a formal leadership role or not, act like owners, magical things can happen. She shares ideas that we can apply to our own work, and talks about how to recognize when we don’t live up to our own expectations of acting like an owner. Filmed at qconsf.com.
Katharina Probst is a Senior Engineering Leader, Kubernetes & SaaS at Google. Before this, she was leading engineering teams at Netflix, being responsible for the Netflix API, which helps bring Netflix streaming to millions of people around the world. Prior to joining Netflix, she was in the cloud computing team at Google, where she saw cloud computing from the provider side.
Does Java Need Inline Types? What Project Valhalla Can Bring to JavaC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2T04Lw4.
Sergey Kuksenko talks about the performance benefits inline types bring to Java and how to exploit them. Inline/value types are the key part of experimental project Valhalla, which should bring new abilities to the Java language. Filmed at qconsf.com.
Sergey Kuksenko is a Java Performance Engineer at Oracle working on a variety of Java and JVM performance enhancements. He started working as Java Engineer in 1996 and as Java Performance Engineer in 2005. He has had a passion for exploring how Java works on modern hardware.
Do you need service meshes in your tech stack?
This on-line guide aims to answer pertinent questions for software architects and technical leaders, such as: what is a service mesh?, do I need a service mesh?, how do I evaluate the different service mesh offerings? In software architecture, a service mesh is a dedicated infrastructure layer for facilitating service-to-service communications between microservices, often using a sidecar proxy.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2UgQ3BU.
Christie Wilson describes what to expect from CI/CD in 2019, and how Tekton is helping bring that to as many tools as possible, such as Jenkins X and Prow. Wilson talks about Tekton itself and performs a live demo that shows how cloud native CI/CD can help debug, surface and fix mistakes faster. Filmed at qconsf.com.
Christie Wilson is a software engineer at Google, currently leading the Tekton project. Over the past decade, she has worked in the mobile, financial and video game industries. Prior to working at Google she led a team of software developers to build load testing tools for AAA video game titles, and founded the Vancouver chapter of PyLadies.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2S7lDiS.
Sasha Rosenbaum shows how a CI/CD pipeline for Machine Learning can greatly improve both productivity and reliability. Filmed at qconsf.com.
Sasha Rosenbaum is a Program Manager on the Azure DevOps engineering team, focused on improving the alignment of the product with open source software. She is a co-organizer of the DevOps Days Chicago and the DeliveryConf conferences, and recently published a book on Serverless computing in Azure with .NET.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/36epVKg.
Todd Montgomery discusses the techniques and lessons learned from implementing Aeron Cluster. His focus is on how Raft can be implemented on Aeron, minimizing the network round trip overhead, and comparing single process to a fully distributed cluster. Filmed at qconsf.com.
Todd Montgomery is a networking hacker who has researched, designed, and built numerous protocols, messaging-oriented middleware systems, and real-time data systems, done research for NASA, contributed to the IETF and IEEE, and co-founded two startups. He currently works as an independent consultant and is active in several open source projects.
Architectures That Scale Deep - Regaining Control in Deep SystemsC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2FWc5Sk.
Ben Sigelman talks about "Deep Systems", their common properties and re-introduces the fundamentals of control theory from the 1960s, including the original conceptualizations of Observability & Controllability. He uses examples from Google & other companies to illustrate how deep systems have damaged people's ability to observe software, and what needs to be done in order to regain control. Filmed at qconsf.com.
Ben Sigelman is a co-founder and the CEO at LightStep, a co-creator of Dapper (Google’s distributed tracing system), and co-creator of the OpenTracing and OpenTelemetry projects (both part of the CNCF). His work and interests gravitate towards observability, especially where microservices, high transaction volumes, and large engineering organizations are involved.
ML in the Browser: Interactive Experiences with Tensorflow.jsC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/39SddUL.
Victor Dibia provides a friendly introduction to machine learning, covers concrete steps on how front-end developers can create their own ML models and deploy them as part of web applications. He discusses his experience building Handtrack.js - a library for prototyping real time hand tracking interactions in the browser. Filmed at qconsf.com.
Victor Dibia is a Research Engineer with Cloudera’s Fast Forward Labs. Prior to this, he was a Research Staff Member at the IBM TJ Watson Research Center, New York. His research interests are at the intersection of human computer interaction, computational social science, and applied AI.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2s9T3Vl.
Colin Eberhardt looks at some of the internals of WebAssembly, explores how it works “under the hood”, and looks at how to create a (simple) compiler that targets this runtime. Filmed at qconsf.com.
Colin Eberhardt is the Technology Director at Scott Logic, a UK-based software consultancy where they create complex application for their financial services clients. He is an avid technology enthusiast, spending his evenings contributing to open source projects, writing blog posts and learning as much as he can.
User & Device Identity for Microservices @ Netflix ScaleC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2S9tOgy.
Satyajit Thadeshwar provides useful insights on how Netflix implemented a secure, token-agnostic, identity solution that works with services operating at a massive scale. He shares some of the lessons learned from this process, both from architectural diagrams and code. Filmed at qconsf.com.
Satyajit Thadeshwar is an engineer on the Product Edge Access Services team at Netflix, where he works on some of the most critical services focusing on user and device authentication. He has more than a decade of experience building fault-tolerant and highly scalable, distributed systems.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2Ezs08q.
Justin Ryan talks about Netflix’ scalability issues and some of the ways they addressed it. He shares successes they’ve had from unintuitively partitioning computation into multiple services to get better runtime characteristics. He introduces us to useful probabilistic data structures, innovative bi-directional data passing, open-source projects available from Netflix that make this all possible. Filmed at qconsf.com.
Justin Ryan is Playback Edge Engineering at Netflix. He works on some of the most critical services at Netflix, specifically focusing on user and device authentication. Years of building developer tools has also given him a healthy set of opinions on developer productivity.
Make Your Electron App Feel at Home EverywhereC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2Z4ZJjn.
Kilian Valkhof discusses the process of making an Electron app feel at home on all three platforms: Windows, MacOS and Linux, making devs aware of the pitfalls and how to avoid them. Filmed at qconsf.com.
Kilian Valkhof is a Front-end Developer & User-experience Designer at Firstversionist. He writes about various topics, from design to machine learning, on his personal website, kilianvalkhof.com and is a frequent contributer to open source software. He is part of the Electron governance team that oversees the development of the Electron framework.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/344PnB1.
Steve Klabnik goes over the deep details of how async/await works in Rust, covering concepts like coroutines, generators, stack-less vs stack-ful, "pinning", and more. Filmed at qconsf.com.
Steve Klabnik is on the core team of Rust, leads the documentation team, and is an author of "The Rust Programming Language." He is a frequent speaker at conferences and is a prolific open source contributor, previously working on projects such as Ruby and Ruby on Rails.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2OUz6dt.
Chris Riccomini talks about the current state-of-the-art in data pipelines and data warehousing, and shares some of the solutions to current problems dealing with data streaming and warehousing. Filmed at qconsf.com.
Chris Riccomini works as a Software Engineer at WePay.
Automated Testing for Terraform, Docker, Packer, Kubernetes, and MoreC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2rm4hFD.
Yevgeniy Brikman talks about how to write automated tests for infrastructure code, including the code written for use with tools such as Terraform, Docker, Packer, and Kubernetes. Topics covered include: unit tests, integration tests, end-to-end tests, dependency injection, test parallelism, retries and error handling, static analysis, property testing and CI / CD for infrastructure code. Filmed at qconsf.com.
Yevgeniy Brikman is the co-founder of Gruntwork, a company that provides DevOps as a Service. He is the author of two books published by O'Reilly Media: Hello, Startup and Terraform: Up & Running. Previously, he worked as a software engineer at LinkedIn, TripAdvisor, Cisco Systems, and Thomson Financial.
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
Generating a custom Ruby SDK for your web service or Rails API using Smithyg2nightmarescribd
Have you ever wanted a Ruby client API to communicate with your web service? Smithy is a protocol-agnostic language for defining services and SDKs. Smithy Ruby is an implementation of Smithy that generates a Ruby SDK using a Smithy model. In this talk, we will explore Smithy and Smithy Ruby to learn how to generate custom feature-rich SDKs that can communicate with any web service, such as a Rails JSON API.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
Securing your Kubernetes cluster_ a step-by-step guide to success !
Catastrophic Cancellation
1.
2. InfoQ.com: News & Community Site
• 750,000 unique visitors/month
• Published in 4 languages (English, Chinese, Japanese and Brazilian
Portuguese)
• Post content from our QCon conferences
• News 15-20 / week
• Articles 3-4 / week
• Presentations (videos) 12-15 / week
• Interviews 2-3 / week
• Books 1 / month
Watch the video with slide
synchronization on InfoQ.com!
http://www.infoq.com/presentations
/IEEE754
http://www.infoq.com/presentati
ons/nasa-big-data
http://www.infoq.com/presentati
ons/nasa-big-data
3. Presented at QCon London
www.qconlondon.com
Purpose of QCon
- to empower software development by facilitating the spread of
knowledge and innovation
Strategy
- practitioner-driven conference designed for YOU: influencers of
change and innovation in your teams
- speakers and topics driving the evolution and innovation
- connecting and catalyzing the influencers and innovators
Highlights
- attended by more than 12,000 delegates since 2007
- held in 9 cities worldwide
5. Intro/Disclaimers
• Aims:
• Get a rough “feel” of how floating point works
• Know when to dig deeper
• Cover basics, testing, and optimisation
• Not an exhaustive trudge through algorithms + details
• This talk: IEEE754 – mostly, but not quite ubiquitous
• Mostly C/Python examples, Linux/x86_64
• No complex numbers
• Code samples available!
6. A problem (C)
#include <values.h>
float a = MAXINT; // 2147483648
float b = MAXLONG; // 9223372036854775808
float f = a + b;
f == MAXLONG; // True or false?
Code ex. 1
7. A problem (C)
#include <values.h>
float a = MAXINT; // 2147483648
float b = MAXLONG; // 9223372036854775808
float f = a + b;
f == MAXLONG; // True or false?
// True!
// IEEE754 only approximates real arithmetic
Code ex. 1
8. How is arithmetic on reals
approximated?
// float gives about 7 digits of accuracy
*******---.------
MAXINT: 2147483648.000000
MAXLONG: 9223372036854775808.000000
*******------------.------
// ^ ^
// | |
// Represented “Lost” beneath
// unit of
// least precision
16. Floating point closed arithmetic
• Integer arithmetic:
• 1/0 // Arithmetic exception
• Floating point arithmetic is closed:
• Domain (double):
• 2.22507e-308 <-> 1.79769e+308
• 4.94066e-324 <-> just beneath 2.22507e-308
• +0, -0
• Inf
• NaN
• Exceptions are exceptional – traps are
exceptions
Code ex. 4, 5
17. A few exceptional values
1/0 = Inf // Limit
-1/0 = -Inf // Limit
0/0 = NaN // 0/x = 0, x/0 = Inf
Inf/Inf = NaN // Magnitudes unknown
Inf + (-Inf) = NaN // Magnitudes unknown
0 * Inf = NaN // 0*x = 0, Inf*x = Inf
sqrt(x), x<0 = NaN // No complex
Code ex. 6
18. Consequences
// Inf, NaN propagation:
double n = 1000.0;
for(double i = 0.0; i < 100.0; i += 1.0)
n = n / i;
printf(“%f”, n); // “Inf”
Code ex. 7
19. Trapping exceptions (Linux, GNU)
• feenableexcept(int __excepts)
• FE_INXACT – Inexact result
• FE_DIVBYZERO - Division by zero
• FE_UNDERFLOW - Underflow
• FE_OVERFLOW - Overflow
• FE_INVALID - Invalid operand
• SIGFPE Not exclusive to floating point:
• int i = 0; int j = 1; j/i // Receives SIGFPE!
Code ex. 8-12
20. Back in the normal range
Some exceptional inputs
to some math library functions
result in normal-range results:
x = tanh(Inf) // x is 1.0
y = atan(Inf) // y is pi/2
(ISO C / IEEE Std 1003.1-2001)
Code ex. 13
21. Denormals
• x – y == 0 implies x == y ?
• Without denormals, this is not true:
• X = 2.2250738585072014e-308
• Y = 2.2250738585072019e-308 // (5e-324)
• Y – X = 0
• With denormals:
• 4.9406564584124654e-324
• Denormal implementation e = 0:
• Implied leading 1 is not a 1 anymore
• Performance: revisited later
Code ex. 14
23. Assumptions
• Code that does floating-point computation
• Needs tests to ensure:
• Correct results
• Handling of exceptional cases
• A function to compare floating point numbers is
required
33. Division vs Reciprocal multiply
// Slower (generally)
a = x/y; // Divide instruction
// Faster (generally)
y1 = 1.0/y; // x86: RCPSS instruction
a = x*y1; // Multiply instruction
// May lose precision.
// GCC: -freciprocal-math
Code ex. 22
34. Non-associativity
float a = 1.0e23;
float b = -1.0e23;
float c = 1.0;
printf("(a + b) + c = %fn", (a + b) + c);
printf("a + (b + c) = %fn", a + (b + c));
(a + b) + c = 1.000000
a + (b + c) = 0.000000
Code ex. 23
35. Non-associativity (2)
• Re-ordering is “unsafe”
• Turned off in compilers by default
• Enable (gcc):
-fassociative-math
• Turns on –fno-trapping, also –fno-
signed-zeros (may affect -0 == 0, flip sign
of -0*x)
36. Finite math only
• Assume that no Infs or NaNs are ever produced.
• Saves execution time: no code for checking/dealing
with them need be generated.
• GCC: -ffinite-math-only
• Any code that uses an Inf or NaN value will
probably behave incorrectly
• This can affect your tests! Inf == Inf may not be
true anymore.
37. -ffast-math
• Turns on all the optimisations we’ve just discussed.
• Also sets flush-to-zero/denormals-are-zero
• Avoids overhead of dealing with denormals
• x – y == 0 -> x == y may not hold
• For well-tested code:
• Turn on –ffast-math
• Do tests pass?
• If not, break into individual flags and test again.
38. -ffast-math linkage
• Also causes non-standard code to be linked in and
called
• e.g. crtfastmath.c set_fast_math()
• This can cause havoc when linking with other code.
• E.g. Java requires option to deal with this:
• -XX:RestoreMXCSROnJNICalls
39. Summary guidelines
• Refactoring and reordering of floating point can
increase performance
• Can also be unsafe
• Some transformations can be enabled by compiler
• Manual implementation also possible
• Make sure code well-tested
• Be prepared for trouble!
41. Floating point
• Finite approximation to real arithmetic
• Some “corner” cases:
• Denormals, +/- 0
• Inf, NaN
• Testing requires appropriate choice of:
• Comparison algorithm
• Expected tolerance and range
• Optimisation:
• For well-tested code
• Reciprocal, associativity, disable “edge case” handling
• FP can be a useful approximation to real arithmetic