Rust is a new systems programming language designed for safety, concurrency, and speed. It uses a borrow checker to ensure memory safety and avoid use-after-free bugs, and enables safe concurrency through message passing and ownership rules. The Rust team has been redesigning and implementing the language over the past year based on lessons learned from writing the compiler in Rust. Their goals are to have a memory-safe, concurrent language that achieves performance comparable to C++. They plan to use Rust for the parallel engine of the Servo browser project.
Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/28XnVtb.
Felix Klock describe the core concepts of the Rust language (ownership, borrowing, and lifetimes), as well as the tools beyond the compiler for open source software component distribution (cargo, crates.io). Filmed at qconlondon.com.
Felix Klock is a research engineer at Mozilla, where he works on the Rust compiler, runtime libraries, and language design. He previously worked on the ActionScript Virtual Machine for the Adobe Flash runtime. Klock is one of the developers of the Larceny Scheme language runtime.
An introduction to Rust: the modern programming language to develop safe and ...Claudio Capobianco
Rust is a young programming language developed by Mozilla with the open source community support. According to a survey of StackOverflow, in 2016 was the most loved among developers language! The goal of Rust is to combine control and performances, that is, operate at low level with high-level constructs. The actual applications vary from operating system to web development. Rust natively includes tools for Agile development, such as dependency management, testing and much more. The gap with other popular languages is filling up quickly thanks to the community, very active and fantastic :)
In this introductory presentation we will discuss the characteristics that make Rust unique, including the concepts of Ownership, Borrowing, and Lifetimes.
These slide has be presented for a talk in BIC Lazio Casilina, that has been also the first meetup of Rust Rome!
Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1mn7lIO.
Aaron Turon explains Rust's core notion of “ownership” and shows how Rust uses it to guarantee thread safety, amongst other things. He also talks about how Rust goes beyond addressing the pitfalls of C++ to do something even more exciting: unlock a new generation of systems programmers by providing a safe, high-level experience -- while never compromising on performance. Filmed at qconsf.com.
Aaron Turon manages the Rust team at Mozilla Research. His background is in low-level concurrency and programming language design.
Rust
Why do you care about Rust? Who has the time to learn all these new languages? It seems like a new one is popping up every other week and this trend is growing at an exponential rate. Good news, a fair number of them are crafted really well and efficiently solve specific problems. Bad news, how do you keep up with all of this, let alone decide which languages to include in your companies technology portfolio.
Despite the challenges of all these new languages, a majority of developers are intrigued about the idea of becoming a polyglot, but don't know where to begin or don't have the time. In my polyglot travels, there is one language of late that is the sure-fire answer to the above questions, Rust.
In this talk I’ll explore the value behind becoming more polyglotic as a developer, how to pick languages to learn, and then dive deep in the the language of Rust. Which in my opinion, is hands down the best up and coming languages to learn.
About the Presenter
Anthony Broad-Crawford has been a developer since the year 2000 with a short side stint as a semi-professional poker player. Since his transition to software development Anthony has...
1. Built 8 patent receiving technologies
2. Founded two global companies
3. Been a CTO (3x), CPO (1x), and CEO (1x)
and is currently the CTO at Fooda where he manages product, user experience, and engineering. Fooda is predominantly web and mobile technology company focused on bringing great & healthy food from the best restaurant's to people while at the office.
Through his career, in production applications Anthony has used Ruby, Java, Jave (Android), Objective-C and Swift, .NET, Erlang, Scala, Node.JS, LISP, Smalltalk, and even assembly, with his recent favorite, Rust . No, not all at the same time in the same application.
Anthony now spends his time building great teams, that leverage great technology, to build great products, but still looks to codes every chance he can get :)
Rust: Reach Further (from QCon Sao Paolo 2018)nikomatsakis
Rust is a new programming language that is growing rapidly. Rust's goal is to support a high-level coding style while offering performance comparable to C and C++ as well as minimal runtime requirements -- it does not require a runtime or garbage collector, and you can even choose to forego the standard library. At the same time, Rust offers strong support for parallel programming, including guaranteed freedom from data-races (something that GC’d languages like Java or Go do not provide).
Rust’s slim runtime requirements make it an ideal choice for integrating into other languages and projects. Anywhere that you could integrate a C or C++ library, you can choose to use Rust instead. Mozilla, for example, has rewritten a portion of the Firefox web browser in Rust -- while keeping the rest in C++. There are also projects for writing native extensions to Python, Ruby, and Node in Rust, as well as a recent effort to have the Rust compiler generate WebAssembly.
This talk will cover some of the highlights of Rust's design, and show how Rust's type system not only supports different parallel styles but also encourages users to write code that is amenable to parallelization. I'll also talk a bit about some of the experiences of using Rust in production, as well as how to integrate Rust into existing projects written in different languages.
Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/28XnVtb.
Felix Klock describe the core concepts of the Rust language (ownership, borrowing, and lifetimes), as well as the tools beyond the compiler for open source software component distribution (cargo, crates.io). Filmed at qconlondon.com.
Felix Klock is a research engineer at Mozilla, where he works on the Rust compiler, runtime libraries, and language design. He previously worked on the ActionScript Virtual Machine for the Adobe Flash runtime. Klock is one of the developers of the Larceny Scheme language runtime.
An introduction to Rust: the modern programming language to develop safe and ...Claudio Capobianco
Rust is a young programming language developed by Mozilla with the open source community support. According to a survey of StackOverflow, in 2016 was the most loved among developers language! The goal of Rust is to combine control and performances, that is, operate at low level with high-level constructs. The actual applications vary from operating system to web development. Rust natively includes tools for Agile development, such as dependency management, testing and much more. The gap with other popular languages is filling up quickly thanks to the community, very active and fantastic :)
In this introductory presentation we will discuss the characteristics that make Rust unique, including the concepts of Ownership, Borrowing, and Lifetimes.
These slide has be presented for a talk in BIC Lazio Casilina, that has been also the first meetup of Rust Rome!
Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1mn7lIO.
Aaron Turon explains Rust's core notion of “ownership” and shows how Rust uses it to guarantee thread safety, amongst other things. He also talks about how Rust goes beyond addressing the pitfalls of C++ to do something even more exciting: unlock a new generation of systems programmers by providing a safe, high-level experience -- while never compromising on performance. Filmed at qconsf.com.
Aaron Turon manages the Rust team at Mozilla Research. His background is in low-level concurrency and programming language design.
Rust
Why do you care about Rust? Who has the time to learn all these new languages? It seems like a new one is popping up every other week and this trend is growing at an exponential rate. Good news, a fair number of them are crafted really well and efficiently solve specific problems. Bad news, how do you keep up with all of this, let alone decide which languages to include in your companies technology portfolio.
Despite the challenges of all these new languages, a majority of developers are intrigued about the idea of becoming a polyglot, but don't know where to begin or don't have the time. In my polyglot travels, there is one language of late that is the sure-fire answer to the above questions, Rust.
In this talk I’ll explore the value behind becoming more polyglotic as a developer, how to pick languages to learn, and then dive deep in the the language of Rust. Which in my opinion, is hands down the best up and coming languages to learn.
About the Presenter
Anthony Broad-Crawford has been a developer since the year 2000 with a short side stint as a semi-professional poker player. Since his transition to software development Anthony has...
1. Built 8 patent receiving technologies
2. Founded two global companies
3. Been a CTO (3x), CPO (1x), and CEO (1x)
and is currently the CTO at Fooda where he manages product, user experience, and engineering. Fooda is predominantly web and mobile technology company focused on bringing great & healthy food from the best restaurant's to people while at the office.
Through his career, in production applications Anthony has used Ruby, Java, Jave (Android), Objective-C and Swift, .NET, Erlang, Scala, Node.JS, LISP, Smalltalk, and even assembly, with his recent favorite, Rust . No, not all at the same time in the same application.
Anthony now spends his time building great teams, that leverage great technology, to build great products, but still looks to codes every chance he can get :)
Rust: Reach Further (from QCon Sao Paolo 2018)nikomatsakis
Rust is a new programming language that is growing rapidly. Rust's goal is to support a high-level coding style while offering performance comparable to C and C++ as well as minimal runtime requirements -- it does not require a runtime or garbage collector, and you can even choose to forego the standard library. At the same time, Rust offers strong support for parallel programming, including guaranteed freedom from data-races (something that GC’d languages like Java or Go do not provide).
Rust’s slim runtime requirements make it an ideal choice for integrating into other languages and projects. Anywhere that you could integrate a C or C++ library, you can choose to use Rust instead. Mozilla, for example, has rewritten a portion of the Firefox web browser in Rust -- while keeping the rest in C++. There are also projects for writing native extensions to Python, Ruby, and Node in Rust, as well as a recent effort to have the Rust compiler generate WebAssembly.
This talk will cover some of the highlights of Rust's design, and show how Rust's type system not only supports different parallel styles but also encourages users to write code that is amenable to parallelization. I'll also talk a bit about some of the experiences of using Rust in production, as well as how to integrate Rust into existing projects written in different languages.
Despite being a slow interpreter, Python is a key component in high-performance computing (HPC). Python is easy to use. C++ is fast. Together they are a beautiful blend. A new tool, pybind11, makes this approach even more attractive to HPC code. It focuses on the niceties C++11 brings in. Beyond the syntactic sugar around the Python C API, it is interesting to see how pybind11 handles the vast difference between the two languages, and what matters to HPC.
Clime is a Python library which lets you convert any module into a multi-command CLI program without any configuration.
It is a short tour of Clime.
The full documentation of Clime: http://clime.mosky.tw/.
Fast as C: How to Write Really Terrible JavaCharles Nutter
For years we’ve been told that the JVM’s amazing optimizers can take your running code and make it “fast” or “as fast as C++” or “as fast as C”…or sometimes “faster than C”. And yet we don’t often see this happen in practice, due in large part to (good and bad) development patterns that have taken hold in the Java world.
In this talk, we’ll explore the main reasons why Java code rarely runs as fast as C or C++ and how you can write really bad Java code that the JVM will do a better job of optimizing. We’ll take some popular microbenchmarks and burn them to the ground, monitoring JIT logs and assembly dumps along the way.
Новый InterSystems: open-source, митапы, хакатоныTimur Safin
Presentation for the 1st InterSystems Meetup in the Minsk:
- New and better InterSystems changes their practice.
- open-source repositories, meetups, and hackathon;
- CPM (package manager) as a good example of open-source project
HexRaysCodeXplorer: object oriented RE for fun and profitAlex Matrosov
HexRaysCodeXplorer - Hex-Rays Decompiler plugin for easier code navigation. Here are the main features of the plugin:
- Automatic type REconstruction for C++ objects.
- C-tree graph visualization - a special tree-like structure representing a decompiled routine in c_itemt terms. Useful feature for understanding how the decompiler works.
- Navigation through virtual function calls in HexRays Pseudocode window.
- Object Explorer - useful interface for navigation through virtual tables (VTBL) structures.
In this presentation, the authors of HexRaysCodeXplorer will be discussing main functionality of the plugin and its application for reverse engineering. The authors will be presenting the algorithm for C++ type REconstruction. Also a special version of HexRaysCodeXplorer (H2HC edition) will be released with new features developed specially for H2Cconference. New features will be committed to GitHub from the stage.
HexRaysCodeXplorer: make object-oriented RE easierAlex Matrosov
HexRaysCodeXplorer - Hex-Rays Decompiler plugin for easier code navigation. Here are the main features of the plugin:
- Automatic type REconstruction for C++ objects.
- C-tree graph visualization – a special tree-like structure representing a decompiled routine in c_itemt terms. Useful feature for understanding how the decompiler works.
- Navigation through virtual function calls in HexRays Pseudocode window.
- Object Explorer – useful interface for navigation through virtual tables (VTBL) structures.
In this presentation authors of HexRaysCodeXplorer will be discussing main functionality of the plugin and its application for reverse engineering. The authors will be presenting the algorithm for C++ type REconstruction. Also a special version of HexRaysCodeXplorer (ZeroNigths edition) will be released with new features developed specially for ZeroNights conference. New features will be committed GitHub from the stage
Despite being a slow interpreter, Python is a key component in high-performance computing (HPC). Python is easy to use. C++ is fast. Together they are a beautiful blend. A new tool, pybind11, makes this approach even more attractive to HPC code. It focuses on the niceties C++11 brings in. Beyond the syntactic sugar around the Python C API, it is interesting to see how pybind11 handles the vast difference between the two languages, and what matters to HPC.
Clime is a Python library which lets you convert any module into a multi-command CLI program without any configuration.
It is a short tour of Clime.
The full documentation of Clime: http://clime.mosky.tw/.
Fast as C: How to Write Really Terrible JavaCharles Nutter
For years we’ve been told that the JVM’s amazing optimizers can take your running code and make it “fast” or “as fast as C++” or “as fast as C”…or sometimes “faster than C”. And yet we don’t often see this happen in practice, due in large part to (good and bad) development patterns that have taken hold in the Java world.
In this talk, we’ll explore the main reasons why Java code rarely runs as fast as C or C++ and how you can write really bad Java code that the JVM will do a better job of optimizing. We’ll take some popular microbenchmarks and burn them to the ground, monitoring JIT logs and assembly dumps along the way.
Новый InterSystems: open-source, митапы, хакатоныTimur Safin
Presentation for the 1st InterSystems Meetup in the Minsk:
- New and better InterSystems changes their practice.
- open-source repositories, meetups, and hackathon;
- CPM (package manager) as a good example of open-source project
HexRaysCodeXplorer: object oriented RE for fun and profitAlex Matrosov
HexRaysCodeXplorer - Hex-Rays Decompiler plugin for easier code navigation. Here are the main features of the plugin:
- Automatic type REconstruction for C++ objects.
- C-tree graph visualization - a special tree-like structure representing a decompiled routine in c_itemt terms. Useful feature for understanding how the decompiler works.
- Navigation through virtual function calls in HexRays Pseudocode window.
- Object Explorer - useful interface for navigation through virtual tables (VTBL) structures.
In this presentation, the authors of HexRaysCodeXplorer will be discussing main functionality of the plugin and its application for reverse engineering. The authors will be presenting the algorithm for C++ type REconstruction. Also a special version of HexRaysCodeXplorer (H2HC edition) will be released with new features developed specially for H2Cconference. New features will be committed to GitHub from the stage.
HexRaysCodeXplorer: make object-oriented RE easierAlex Matrosov
HexRaysCodeXplorer - Hex-Rays Decompiler plugin for easier code navigation. Here are the main features of the plugin:
- Automatic type REconstruction for C++ objects.
- C-tree graph visualization – a special tree-like structure representing a decompiled routine in c_itemt terms. Useful feature for understanding how the decompiler works.
- Navigation through virtual function calls in HexRays Pseudocode window.
- Object Explorer – useful interface for navigation through virtual tables (VTBL) structures.
In this presentation authors of HexRaysCodeXplorer will be discussing main functionality of the plugin and its application for reverse engineering. The authors will be presenting the algorithm for C++ type REconstruction. Also a special version of HexRaysCodeXplorer (ZeroNigths edition) will be released with new features developed specially for ZeroNights conference. New features will be committed GitHub from the stage
Видео доклада: https://www.youtube.com/watch?v=slnQBoxsHPU
Rust - системный язык программирования, который быстро исполняется, предотвращает почти все падения, и устраняет гонки по данным.
Как он этого достигает? Про это доклад.
Рассказывается об основах программирования на ruby: переменные, типы переменных, операции и пр. В конце приводятся блок-схема решения линейного уравнения.
Лекция #5. Введение в язык программирования Python 3Яковенко Кирилл
Web-программирование
Лекция #5. Введение в язык программирования Python 3
Цикл лекций читается в Омском государственном университете им. Ф.М.Достоевского на факультете компьютерных наук.
Лектор: Яковенко Кирилл Сергеевич.
What if your database wasn't in just one place, but was all around you? What type of framework will you use in a post-server world? Where should your data be stored, and who's planning it? How tolerant is your system to failure? Unbase is an ideology and aspirational framework for distributed data. Unbase uses a physics-first approach to transcending the server, increasing availability, and meeting user expectations. In this presentation, we discuss key design concepts, their scientific basis, and our goals for building Unbase.
Ruby is Awesome and Rust is Awesome and Building a Game in Both is AWESOMEJulien Fitzpatrick
Learning to program in Ruby was super fun, but I kept hearing people talk about typed languages that are so-called "closer to the metal," like Rust. It seemed intimidating, but I was curious! I built a small, text-based adventure game in both Ruby and Rust, side-by-side, so I could see what the differences and similarities were. I learned a lot, and now I'm here to share it all with you!
3 Things Every Sales Team Needs to Be Thinking About in 2017Drift
Thinking about your sales team's goals for 2017? Drift's VP of Sales shares 3 things you can do to improve conversion rates and drive more revenue.
Read the full story on the Drift blog here: http://blog.drift.com/sales-team-tips
A presentation at Twitter's official developer conference, Chirp, about why we use the Scala programming language and how we build services in it. Provides a tour of a number of libraries and tools, both developed at Twitter and otherwise.
Tips and Tricks for Increased Development EfficiencyOlivier Bourgeois
Short presentation targetted at university students showing some tools and software that are usually not talked about in courses which helps development productivity.
Script of ScriptsPolyglot Notebook and Workflow SystemBo Peng
Script of ScriptsPolyglot Notebook and Workflow System for both Interactive Multi-language Data Analysis and Batch Data Processing. Video at https://youtu.be/U75eKosFbp8
C Language review. its review about arrays, Strings, pointers etc.. The first high-level programming languages were designed in the 1950s. Now there are dozens of
different languages, including Ada , Algol, BASIC, COBOL, C, C++, JAVA, FORTRAN, LISP,
Pascal, and Prolog. Such languages are considered high-level because they are closer to human
languages and farther from machine languages. In contrast, assembly languages are considered lowlevel because they are very close to machine languages. High-level language is any programming language that enables development of a program in much
simpler programming context and is generally independent of the computer's hardware architecture.
High-level language has a higher level of abstraction from the computer, and focuses more on the
programming logic rather than the underlying hardware components such as memory addressing and
register utilization. Machine code or machine language is a set of instructions executed directly by a computer's central
processing unit (CPU). Each instruction performs a very specific task, such as a load, a jump, or an
ALU operation on a unit of data in a CPU register or memory. Every program directly executed by a CPU is made up of a series of such instructions.
Polymorphism means the ability to take more than one form. An operation may exhibit different
instance. The behaviour depends upon the type of data used in the operation.
A language feature that allows a function or operator to be given more than one definition. The types
of the arguments with which the function or operator is called determines which definition will be
used.
Overloading may be operator overloading or function overloading.
RSYSLOG v8 improvements and how to write plugins in any language.Rainer Gerhards
RSYSLOG is a next generation log processing tool. In the frist part, we will explain the new RSYSLOG v8 engine, its motivation and its benefits. Learn, for example, why writing to Elasticsearch is much faster with the new engine. We will describe the tuning parameters vital for making best use of the new features.
In the second part we will explain how to write RSYSLOG plugins in any language. Traditionally, writing rsyslog plugins has been considered quite hard, with at least C knowledge necessary. In v8, we have introduced new interfaces which make it possible to write plugins in any language - be it Python, Perl or Java. Even bash will do. In essence, this is a great tool for any admin to add special needs with just a bit of scripting. We will proivde concrete instructions on how to write a plugin, point to read-to-copy samples and tell how to integrate this into rsyslog.
NOTE: This is my LinuxTag Berlin 2014 talk.
Elevating Tactical DDD Patterns Through Object CalisthenicsDorra BARTAGUIZ
After immersing yourself in the blue book and its red counterpart, attending DDD-focused conferences, and applying tactical patterns, you're left with a crucial question: How do I ensure my design is effective? Tactical patterns within Domain-Driven Design (DDD) serve as guiding principles for creating clear and manageable domain models. However, achieving success with these patterns requires additional guidance. Interestingly, we've observed that a set of constraints initially designed for training purposes remarkably aligns with effective pattern implementation, offering a more ‘mechanical’ approach. Let's explore together how Object Calisthenics can elevate the design of your tactical DDD patterns, offering concrete help for those venturing into DDD for the first time!
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
Essentials of Automations: Optimizing FME Workflows with ParametersSafe Software
Are you looking to streamline your workflows and boost your projects’ efficiency? Do you find yourself searching for ways to add flexibility and control over your FME workflows? If so, you’re in the right place.
Join us for an insightful dive into the world of FME parameters, a critical element in optimizing workflow efficiency. This webinar marks the beginning of our three-part “Essentials of Automation” series. This first webinar is designed to equip you with the knowledge and skills to utilize parameters effectively: enhancing the flexibility, maintainability, and user control of your FME projects.
Here’s what you’ll gain:
- Essentials of FME Parameters: Understand the pivotal role of parameters, including Reader/Writer, Transformer, User, and FME Flow categories. Discover how they are the key to unlocking automation and optimization within your workflows.
- Practical Applications in FME Form: Delve into key user parameter types including choice, connections, and file URLs. Allow users to control how a workflow runs, making your workflows more reusable. Learn to import values and deliver the best user experience for your workflows while enhancing accuracy.
- Optimization Strategies in FME Flow: Explore the creation and strategic deployment of parameters in FME Flow, including the use of deployment and geometry parameters, to maximize workflow efficiency.
- Pro Tips for Success: Gain insights on parameterizing connections and leveraging new features like Conditional Visibility for clarity and simplicity.
We’ll wrap up with a glimpse into future webinars, followed by a Q&A session to address your specific questions surrounding this topic.
Don’t miss this opportunity to elevate your FME expertise and drive your projects to new heights of efficiency.
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.
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.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
Key Trends Shaping the Future of Infrastructure.pdfCheryl Hung
Keynote at DIGIT West Expo, Glasgow on 29 May 2024.
Cheryl Hung, ochery.com
Sr Director, Infrastructure Ecosystem, Arm.
The key trends across hardware, cloud and open-source; exploring how these areas are likely to mature and develop over the short and long-term, and then considering how organisations can position themselves to adapt and thrive.
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
2. Overview
• What is Rust?
• How has the Rust design evolved over the past year?
• How far have we come in implementation?
• What are we going to use Rust for?
3. What is Rust?
use std;
import std::{ int, vec };
fn main(grades : [str]) {
let results = vec::map({ |s|
if int::parse(s) >= 70 { “Pass” }
else { “Fail” }
}, grades);
log results;
}
4. What is Rust?
• Rust is a new systems programming language designed for
safety, concurrency, and speed.
• It was originally conceived by Graydon Hoare and is now
developed by a team in Mozilla Research and the community.
5. What is Rust? — Safety
• Rust has no null pointers. The typical replacement for a
nullable pointer is std::option<T>.
• Rust is memory-safe, outside of designated unsafe blocks,
which can be easily audited.
• Rust features typestate, an analysis that allows the compiler to
track predicates that you define.
6. What is Rust?—Typestate
• Typestate isn’t new—it’s in Java!
public static void main() {
String s;
if (new Date().getHours() < 12)
s = “Good morning!”
System.out.println(s); // Error: s may be uninitialized
}
7. What is Rust?—Typestate
• The same initialization checking takes place in Rust through the
typestate system and the so-called init predicate. Each value
must hold the init predicate (i.e. be initialized) before use.
fn main() {
let s : str;
if date::localtime(date::now()).hours < 12u {
s = “Good morning!”
}
log s; // Error: predicate ‘init’ does not hold
}
8. What is Rust?—Typestate
• Beyond this, Rust allows you to define your own predicates.
• Functions can demand that certain predicates be true before
calling them is allowed.You can also use values with predicates
as first-class types, such as int|prime.
• You use the check statement to make the Rust compiler
aware of assertions that you’re performing. The assertion is
checked at runtime, and the program aborts if the assertion
fails.
9. What is Rust?—Typestate
• Suppose we have these declarations:
pred in_range(array : [int], start : uint, end : uint) {
start < end && end < vec::len(array)
}
fn slice(array : [int], start : uint, end : uint)
-> [int] : in_range(array, start, end) { ... }
10. What is Rust?—Typestate
• Then we can’t call slice in the normal way:
fn main() {
let v = [ 1, 2, 3, 4, 5 ];
log v.slice(2, 3); // error: predicate
//‘in_range(v, 2, 3)’ does
// not hold
}
11. What is Rust?—Typestate
• But we can if we use a check statement:
fn main() {
let v = [ 1, 2, 3, 4, 5 ];
check in_range(v, 2, 3);
log v.slice(2, 3); // OK
}
12. What is Rust?—Typestate
• Why is this useful?
• The Rust compiler remembers the assertions that you’ve
performed, so that you don’t have to perform them
repeatedly.
• With typestate, assertions are in the function signature,
which helps make functions self-documenting.
13. What is Rust?—Concurrency
• Rust is designed for concurrency on a large scale, following
the principles of Erlang.
• You can spawn thousands of tasks in the same process.
• Under the hood, the Rust scheduler spawns one or two OS
threads per CPU and schedules your tasks appropriately.
14. What is Rust?—Concurrency
fn do_something_expensive() -> bigint {
ret factorial(99999999);
}
fn main() {
let task = spawn(do_something_expensive);
log join(task);
}
15. What is Rust?—Concurrency
• While they’re running, tasks can communicate via channels
and ports.
• Ports and channels are typed; e.g. port<int>,
chan<dom_node>.
• Ports are the receiving endpoint; channels are the sending
endpoint. Mnemonic: bodies of water.
• Multiple channels can go to the same port.
16. What is Rust?—Concurrency
fn something_expensive(ch : chan<bignum>) {
send(ch, factorial(99999999));
}
fn main() {
let p = port();
spawn(bind something_expensive(chan(p)));
log recv(p);
}
17. What is Rust?—Concurrency
• Rust ensures that there is no shared state.
• There is no need for mutex locks, condition variables, atomic
operations, or concurrent garbage collection.
• All unique pointers (~) are allocated in a shared heap and
move from task to task by simply copying a pointer.
• All boxed pointers (@) are allocated in task-local heaps and
never move.
18. What is Rust?—Concurrency
• We enforce these concurrency-related invariants through our
type system.
• Unique pointers (denoted by ~) are the only pointers that
can be sent.
• Once you send a unique pointer, you lose access to it.
• This is enforced through typestate; the unique pointer, once
moved, loses its init predicate.
19. What is Rust?—Speed
• We use the LLVM compiler infrastructure, which is used by
the Clang C++ compiler, for the self-hosted compiler.
• We benefit from all of LLVM’s optimization passes.
20. What is Rust?—Speed
• We strive for predictable runtime performance with a
minimum of overhead.
• Performance should be comparable to idiomatic C++; that is,
C++ with use of the STL and avoiding highly unsafe
constructs.
• We also have an unsafe sublanguage that allows direct pointer
manipulation. It’s restricted to blocks and functions marked
unsafe.
21. What is Rust?—Speed
• We support three type layers to make memory management
simple and fast.
• Interior types (denoted with no sigil) are stored on the stack.
• Unique types (denoted with ~) have ownership semantics. When
the pointer goes out of scope, the object it’s pointing to is
destroyed.
• Boxed types (denoted with @) are garbage-collected. Multiple
boxes can point to the same data.
22. What is Rust?—Speed
• All together:
fn main() {
let a = ~3; // Unique pointer to number
let b = a; // Copies a
let c = @3; // Box of number
let d = c; // c & d point to the same value
} // a and b destroyed; c and d will be GC’d
23. Language changes
• A year ago, we announced Rust at the Mozilla Summit.
• Since then, we’ve made a large number of changes to the
language syntax and semantics.
• Writing the Rust compiler in Rust helped us to quickly find
and fix the painful areas of the language.
24. Language changes—Syntax
• One year ago:
fn f(&option.t[str] s) {
auto r;
alt (s) {
case (some(?ss)) { r = rec(x=123, y=ss); }
case (none) { fail; }
}
}
25. Language changes—Syntax
• Today:
fn f(s : option::t<str>) {
let r = alt s {
some(ss) { { x: 123, y: ss } }
none. { fail }
};
}
26. Language changes—Syntax
• Small changes:
• We’ve removed parentheses around if, alt, while, etc.
• Pattern matching syntax has been tweaked. Switch
statements (alt) no longer require case.
• Types now go after variable bindings: let int x is now
written let x : int.
27. Language changes—Closures
• Instead of simply supporting a bind form, we now essentially
have full-featured closures.
• Closures are written as Ruby-style blocks:
vec::eachi([ 1, 2, 3 ], { |x, i| // Parameters
log “Element #“, i, “ is “, x;
});
28. Language changes—Sharing
• When Rust was initially designed, only immutable data
structures could be sent over channels, like Erlang.
• But we still needed copying to avoid global garbage collection.
• What we really need is to avoid sharing, not immutability.
• The immutability restriction is now the ownership restriction—
you can only send data you own, and after you send it you
lose that ownership.
29. Language changes—Macros
• One year ago, macros were more like compiler plugins—they
were DLLs loaded by the rustc compiler that could
manipulate its internal code representation.
• These kinds of macros are still supported, but we wanted
macros to be usable by people other than compiler hackers.
• So now we have macro-by-example, which are pattern-
matching macros like those of Scheme.
30. Current status
How far are we from achieving our goals of safety, concurrency,
and speed?
31. Current status—Safety
• We have a type-safe, memory-safe language with a self-hosted
compiler.
• We have hundreds of unit tests and a testing framework.
• We’re missing garbage collection and stack unwinding.
• The compiler isn’t yet production-quality. Crashes are
uncommon but still happen.
32. Current status—Concurrency
• We have a working concurrency system that operates
similarly to Erlang and Grand Central Dispatch.
• Thousands of simultaneous tasks are supported.
• We’re currently missing growable stacks (to prevent address
space exhaustion), unique pointers and closures (for fast data
sharing), and OS process isolation.
33. Current status—Speed
• Our compiler benefits from LLVM’s optimizations and highly-
tuned code generation.
• On simple numeric kernels, we generally perform well.
• We’re currently slower than we’d like to be on generic code
(type-passing), memory management (too much copying), and
cross-crate calls (no inlining).
36. Servo Project
• Rust is a critical piece of the Servo project, which is a project
to develop a parallel browser engine.
• We don’t know how, or whether, we will ship this engine to
end users at the moment; it’s very much a research project. It
might be a new product, become a part of Gecko/Firefox, or
remain purely a research platform.
• Nevertheless, we want our code to be production quality.
38. Servo Project—Architecture
• Servo is not planned to feature a cross-language component
model.
• Instead, all JavaScript–Rust communication is performed via
the Rust message passing system.
• The single-threaded parts of the browser will run in
JavaScript and communicate asynchronously with the highly
parallel Servo engine written in Rust.
39. Servo Project—Components
• These components are planned to be written in Rust:
• A parallel HTML/JavaScript/SVG/CSS parser.
• A layout engine that performs parallel layout, including CSS
selector matching, box reflows, etc.
40. Servo Project—Components
• These components are planned to remain in C++ for the first
few iteration:
• The SpiderMonkey JavaScript engine.
• The graphics rendering engine “Azure”.
41. Servo Project—Components
• These components will be written in JavaScript and HTML:
• The DOM will be dom.js, in order to avoid the problems of
XPCOM (cross-language cycles, SpiderMonkey optimization
hazards, etc.)
• The UI will be all HTML and JavaScript.
42. Servo Project—Getting Involved
• We’re still in the early stages of development, but you can
help!
• dom.js is actively being worked on and we’d love to have your
help: http://github.com/andreasgal/dom.js
• If you have ideas along the lines of “what I would do if I could
start over from scratch”, particularly if you’re a platform
hacker, we’d like to know!
43. Thanks
• The Rust team
• Brian Anderson (brson)
• Tim Chevalier (tjc)
• Marijn Haverbeke (marijn)
• Dave Herman (dherman, @littlecalculist)
• Graydon Hoare (graydon, @graydon_moz)
44. Thanks
• And the Rust interns:
• Roy Frostig (froystig)
• Eric Holk (eholk, @theinedibleholk)
• Lindsey Kuper (lkuper, @lindsey)
• Paul Stansifer (pauls, @paulstansifer)
• Michael Sullivan (sully)