Beginning nxt programming_workshop in Computer education robotics whoevgjvvvv...OhSoAwesomeGirl
It's all about ROBOTICS. so it can be helpful. get me? hahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbdon't think that i am stupid whahahahahahahahaha
Learn more about Puppet 4 and migrating from Puppet 3 from people who've built it and are using it at PuppetConf 2016 in San Diego. More details: https://puppet.com/puppetconf/
Beginning nxt programming_workshop in Computer education robotics whoevgjvvvv...OhSoAwesomeGirl
It's all about ROBOTICS. so it can be helpful. get me? hahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbdon't think that i am stupid whahahahahahahahaha
Learn more about Puppet 4 and migrating from Puppet 3 from people who've built it and are using it at PuppetConf 2016 in San Diego. More details: https://puppet.com/puppetconf/
Some of the things I learned during the last years from the GURU of the AGILE manifesto.
Be a Clean Coder from Robert C. Martin
Be a Pragmatic Programmer from Andrew Hunt
Be a extreme Programmer from Kent Beck
Understand the Continuous Delivery from Jez Humble and David Farley.
Thanks to Bruno Bossola , Marcello Todori and Mario Romano for the good chats about this topics.
Have you heard of TDD? Are you interested or familiar with this practice but have never been able to understand it?
Join this session to see the benefits of Test-Driven Development (TDD), understand how it works and its benefits. In a more detailed approach, we will see this way of developing software, where our code is always built guided by tests.
We will go over some history about TDD, which is the main process we must follow when we work with this mechanic and the rules that surround it. We will also list the main advantages and disadvantages that most developers who practice TDD find and whether the arguments in favour add up to more than those that subtract. Finally, we will review some good habits and practices when applying TDD and see how to do it step by step with an example of a "live" coding session with Java.
At the end of the session, I hope that you will have a wider understanding of what TDD is, what advantages it brings, why it is interesting to master it and also that you will take with you some tricks and good practices to be able to apply them in your day-to-day life when writing code
---
Presentation shared at Opensouthcode (9th June '23)
Test-Driven Developments are Inefficient; Behavior-Driven Developments are a ...Abdelkrim Boujraf
In summary, we have presented here a method for efficiently testing large parts of web-based software by using elements of code generation to generate automatable tests, and by using BDD concepts to model tests for non-generated screens and non-generated business actions. Further, we have described a method for context-based unit
testing that, when combined with generated code and tests, yields an acceptable trade-off between development efficiency and time spent on testing
Why should we use TDD to develop in Elixir? When we are applying it correctly? What are the differences that we can find in a code developed with TDD and in code not developed with it? Is it TDD about testing? Really? In this talk, I'll show what is TDD and how can be used it in functional programming like Elixir to design the small and the big parts of your system, showing what are the difference and the similarities between an OOP and FP environment. Showing what is the values of applying a technique like TDD in Elixir and what we should obtain applying it.
TDD - Seriously, try it - Codemotion (May '24)Nacho Cougil
Ever wondered about the wonders of Test-Driven Development (TDD)? Curious devs, this session is for you!
Get ready to dive into TDD and explore its benefits. We'll see the "secrets" behind TDD, its roots, and the rules surrounding it. But that's not all! We'll also uncover the ups and downs of TDD, plus we'll share some tips and tricks... including a live coding session in Java. Get ready to level up your development skills with TDD – more insights, more advantages, and more confidence in your coding adventures!
PS: Building tests before production code can sound more fun than it sounds 😉.
---
Presentation shared at Codemotion Madrid '24
Feedback form:
https://bit.ly/tdd-seriously-try-it-feedback
Some of the things I learned during the last years from the GURU of the AGILE manifesto.
Be a Clean Coder from Robert C. Martin
Be a Pragmatic Programmer from Andrew Hunt
Be a extreme Programmer from Kent Beck
Understand the Continuous Delivery from Jez Humble and David Farley.
Thanks to Bruno Bossola , Marcello Todori and Mario Romano for the good chats about this topics.
Have you heard of TDD? Are you interested or familiar with this practice but have never been able to understand it?
Join this session to see the benefits of Test-Driven Development (TDD), understand how it works and its benefits. In a more detailed approach, we will see this way of developing software, where our code is always built guided by tests.
We will go over some history about TDD, which is the main process we must follow when we work with this mechanic and the rules that surround it. We will also list the main advantages and disadvantages that most developers who practice TDD find and whether the arguments in favour add up to more than those that subtract. Finally, we will review some good habits and practices when applying TDD and see how to do it step by step with an example of a "live" coding session with Java.
At the end of the session, I hope that you will have a wider understanding of what TDD is, what advantages it brings, why it is interesting to master it and also that you will take with you some tricks and good practices to be able to apply them in your day-to-day life when writing code
---
Presentation shared at Opensouthcode (9th June '23)
Test-Driven Developments are Inefficient; Behavior-Driven Developments are a ...Abdelkrim Boujraf
In summary, we have presented here a method for efficiently testing large parts of web-based software by using elements of code generation to generate automatable tests, and by using BDD concepts to model tests for non-generated screens and non-generated business actions. Further, we have described a method for context-based unit
testing that, when combined with generated code and tests, yields an acceptable trade-off between development efficiency and time spent on testing
Why should we use TDD to develop in Elixir? When we are applying it correctly? What are the differences that we can find in a code developed with TDD and in code not developed with it? Is it TDD about testing? Really? In this talk, I'll show what is TDD and how can be used it in functional programming like Elixir to design the small and the big parts of your system, showing what are the difference and the similarities between an OOP and FP environment. Showing what is the values of applying a technique like TDD in Elixir and what we should obtain applying it.
TDD - Seriously, try it - Codemotion (May '24)Nacho Cougil
Ever wondered about the wonders of Test-Driven Development (TDD)? Curious devs, this session is for you!
Get ready to dive into TDD and explore its benefits. We'll see the "secrets" behind TDD, its roots, and the rules surrounding it. But that's not all! We'll also uncover the ups and downs of TDD, plus we'll share some tips and tricks... including a live coding session in Java. Get ready to level up your development skills with TDD – more insights, more advantages, and more confidence in your coding adventures!
PS: Building tests before production code can sound more fun than it sounds 😉.
---
Presentation shared at Codemotion Madrid '24
Feedback form:
https://bit.ly/tdd-seriously-try-it-feedback
Lightening Talk I gave at Inaka in April 2014.
I was in charge of investigating test-driven development for our iOS mobile team. Since I realized it was such a big concept, after having gathered enough information and having played with it enough, I decided to introduce my fellows on the topic by presenting it in a formal talk with slides. The aim was teaching them a different way of developing, which, for us, at that moment, was completely new and controversial.
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.
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/
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.
Builder.ai Founder Sachin Dev Duggal's Strategic Approach to Create an Innova...Ramesh Iyer
In today's fast-changing business world, Companies that adapt and embrace new ideas often need help to keep up with the competition. However, fostering a culture of innovation takes much work. It takes vision, leadership and willingness to take risks in the right proportion. Sachin Dev Duggal, co-founder of Builder.ai, has perfected the art of this balance, creating a company culture where creativity and growth are nurtured at each stage.
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.
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.
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.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
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
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.
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!
2. WHAT IT IS?
intensive practice event,
focus on the fundamentals of software development
and design,
focus on skill improvement.
3. WHY WE DO IT?
learn through pairing,
extend your comfort zone,
practice,
experiment,
learn new practices.
4. HOW WE DO IT?
Normally:
organized Saturdays,
it takes a full day (6 sessions).
This code retreat:
organized Wednesday (October 23rd, 2013),
it takes only 3 hours because of work constraints (2
sessions).
5. HOW WE DO IT?
introduction - 30 min
first session – 45 min
retrospective for first session – 15 min
break – 15 min
second session – 45 min
retrospective for second session – 15 min
final retrospective & closing
6. HOW WE DO IT?
only pair programming,
switch pairs when session ends,
use any language
(preferably C# or Java for this retreat),
delete the code when session ends,
do not try to finish the problem,
focus on practice,
enjoy!
7. WHY USE CONSTRAINTS?
learn new things,
expand our comfort zone,
improve the way we design software,
learn communication through tests
(tests as a form of documentation).
8. WHAT CONSTRAINTS?
the four elements of simple design,
no conditionals (if, while, etc),
no primitives (int, boolean etc, just objects),
four lines of code per methods,
law of Demeter (use only one dot per line),
no mouse/touchpad (keyboard only),
no IDE (text editor only),
taking baby steps,
object calisthenics,
immutable objects only.
9. WHAT? PAIR PROGRAMMING GAMES?
ping pong (one person writes the tests, the other
person writes the implementation code to make the
test pass),
mute pairing (no one talks, this improves the
readability of the code),
mute with find the loophole (AKA evil coder; the
implementation person purposely writes the wrong
algorithm that still makes the tests turn green. The
key is that they have to keep the code very clean all
the while. So, no big long if statements parsing on
the input parameters.)
10. WHAT ARE THE RULES FOR
PING PONG PAIR PROGRAMMING?
driver – the one coding at a given moment
copilot – the other developer
1.
2.
3.
4.
the driver writes a test and then hands the
keyboard to the copilot,
the new driver makes the test pass,
they refactor together, passing the keyboard as
necessary,
they reverse roles and start over with a new test.
11. WHAT ENVIRONMENT?
C#
Visual Studio IDE (preferably with ReSharper)
NUnit testing framework
Java
Eclipse or IntelliJ IDEA IDEs
JUnit testing framework
git bash (or any other git client)
12. WHAT DO WE CODE?
traditionally the Conway's Game of Life,
can also be Tic-Tac-Toe, but this has a small
disadvantage: you might be able to finish it in a
session which is not so good.
13. WHAT ARE THE RULES?
having an infinite 2D orthogonal universe
being given an initial generation called seed
the following rules are applied simultaneously
live cells
live cells
live cells
dead cells
revived
with
with
with
with
< 2 live neighbors die
2 or 3 live neighbors live
> 3 live neighbors die
exactly 3 live neighbors will be
check this online simulation to understand better how it works.
14. FIRST SESSION
you have 5 minutes to get prepared,
pick your pair,
use ping pong pair programming,
don’t use constraints,
just get a feel for the problem domain,
start coding (and the countdown timer)!
15. FIRST SESSION’S RETROSPECTIVE
do you find it easy to delete the code?
why do you think we should do that?
what would happen if you didn’t delete it?
17. SECOND SESSION
you have 5 minutes to get prepared,
pick your pair (different than in the first session),
use ping pong pair programming,
pick a constraint,
start coding (and the countdown timer)!
18. SECOND SESSION’S RETROSPECTIVE
is an array the right way to store the cells?
(talk about the “primitive obsession” code smell),
what constraints did you choose and why?
19. FINAL RETROSPECTIVE & CLOSING
what, if anything, did you learn today?
what, if anything, surprised you today?
what, if anything, will you do differently in the
future?
what can be improved regarding the organization of
the code retreat?
20. WANT MORE?
Global Day of Code Retreat (#gdcr twitter hash
tag),
This year on December 14th,
Legacy Code Retreat – practice writing tests,
refactoring, improving the design in existing code
(since many of us don’t have the privilege of
working on a greenfield project),
Coding Katas – programming exercises which help
the programmer to improve his/her skills through
practice and repetition.
22. LINKS
video introduction to code retreats
how others do it: The Orlando Code Retreat Video
main site: coderetreat.org
awesome site by Uncle Bob: cleancoders.com
coding kata catalogue
the software craftsmanship movement
software craftsmanship community (contributor
there)
23. BOOKS
Clean Code
by Robert C. Martin
The Coding Dojo Handbook
by Emily Bache
Refactoring
by Martin Fowler
Working Effectively
with Legacy Code
by Michael Feathers
25. THE FOUR ELEMENTS OF SIMPLE DESIGN
The code:
passes it’s tests (tests always on green),
minimizes duplication (extract methods),
maximizes clarity (better names, SRP, etc),
has fewer elements (less code is better most of the
time).
26. NO CONDITIONAL STATEMENTS
no if/while/switch etc statements
the conditional operator (?:) is permitted
boolean expressions are also permitted
you can also use maps instead of switches
27. NO PRIMITIVES
with this we’re trying to fix the “primitive
obsession” code smell,
it basically means that you shouldn’t use primitive
data types (int, double, boolean, string) to
represent domain ideas,
we introduce a Value Object in place of the
primitives, and other code spread around will be
moved in the Value Object,
this is a way to minimize duplication.
28. FOUR LINES OF CODE PER METHOD
programmers have a way of being “comfortable”
with the code: instead of creating a new method for
something (too hard), they add code to an existing
method making it bigger and harder to test (that is if
they have tests at all),
this constraint will force you to use SRP (the Single
Responsibility Principle),
an easy way to do this is “extract till you drop”
(see Uncle’s Bob Clean Code book) which tells that
you should extract new methods from an existing
one till you don’t have anything else to extract.
29. LAW OF DEMETER – IN PLAIN ENGLISH
also called the principle of least knowledge,
your method can call other methods in its class
directly,
your method can call methods on its own fields
directly (but not on the fields' fields),
when your method takes parameters, your method
can call methods on those parameters directly,
when your method creates local objects, that
method can call methods on the local objects.
30. LAW OF DEMETER – FUNNY DEFINITION
you can play with yourself,
you can play with your own toys (but you can't take
them apart),
you can play with toys that were given to you,
you can play with toys you've made yourself.
Real Life™ analogy: when one wants a dog to
walk, one does not command the dog's legs to walk
directly; instead one commands the dog which then
commands its own legs.
31. NO MOUSE/TOUCHPAD (KEYBOARD ONLY)
programmers who know keyboard shortcuts (to
build, to run tests, to execute) work faster and are
usually less distracted,
you should learn the keyboard shortcut equivalents
for most of the operations you usually do on the
normal work day,
you should know the Windows ones too:
Win + E open new explorer window,
Alt + D go to address bar,
etc.
32. NO IDE (TEXT EDITOR ONLY)
this is addressed to those that work the entire day
in an IDE (Visual Studio, Eclipse, IntelliJ IDEA,
others),
do you know what the IDE does (what commands,
what parameters) for you when you
compile/build/deploy the code?
can you manage to put the imports/usings by hand?
can you work without syntax highlighting? Using
just Notepad (no Notepad++).
33. TAKING BABY STEPS
a small step is sure and steady, whereas when taking a large step you
could be in danger of breaking the tests.
Steps - credits to Adrian Bolboaca
1.
2.
3.
setup source control repository,
setup a timer for 2 minutes interval when you start,
write exactly one test:
A.
B.
4.
5.
restart timer (no discussions in between timers),
refactor
A.
B.
6.
7.
8.
if the timer rings and the test is red then revert and start over,
if the test is green before timer rings then commit.
if the timer rings and the refactoring is not complete then revert and
start over,
if the refactoring is complete before the timer rings then commit.
restart the timer (no discussions in between timers),
go to step 3,
when session time is up delete the code.
34. IMMUTABLE OBJECTS ONLY
no setters for object fields,
easier to debug code when there’s nothing that can
mutate,
extremely helpful when dealing with concurrency,
applicable to value types.