Testing Mozilla DeepSpeech for a Waasabi live transcription usecase

rfg-corpus.txt

10 000 STEPS MIGHT SEEM LIKE A LOT BUT IF YOU NEED TO PLACE 100 BRUSHES THAT IS 8 000 PARAMETERS AND REMEMBER THE ALGORITHM CANNOT REMOVE THEM
20% OF ALL THE CRATES THAT ARE IN CRATES IO USE THEM SAFE DIRECTLY
25 28 29
27 IS NOT A POP
61 AND 62 ARE THE ADDRESSES OF THE SPECIAL REGISTERS FOR THE FRAME POINTER
95% CHANCE THE BUG IS IN THE CODE YOU JUST WROTE
A BAT SENDS SOUND WAVES EVERY NOW AND THEN AND WAITS FOR THEM TO RETURN TO CALCULATE HOW FAR IS IT FROM AN OBSTACLE
A BRIEF OVERVIEW OF THE SYSTEM ARCHITECTURE
A CHANGE IN THE ALGORITHM DOES NOT NECESSARILY REQUIRE A CHANGE TO THE DATA
A CHECKMARK GOES TO THE BEST AND AN X TO THE WORSE AND NO MARK FOR THE COMPRESSOR IN BETWEEN
A FIELD WHICH CAN TAKE ON ONE OF A LIMITED POSSIBLE SET OF VALUES CAN BE MODELLED AS AN ENUM INDICATED IN EACH DRAFTS WITH THE STOCK PHRASE A TCP OPTION IS ONE OF SO IS ONE OF IS THE KEY PHRASE WE NEED TO USE IN THE MODIFIED STANDARD DOCUMENTS
A GAME DESIGN WITH ECS AND MOVING ONE FROM SOMETHING ELSE TO ECS
A GOOD ANALOGY FOR EVENT CHANNELS IS A RADIO BROADCAST
A GPU IS DRIVEN BY DATA SENT TO IT IN A SERIALIZATION FORMAT WE WILL CALL VERTEX BUFFERS WHICH CONTAIN DATA LIKE THE POSITIONS OF THE POINTS THAT MAKE UP POLYGONS COLORS AND MATERIAL NEEDED FOR RENDERING
A JSON DOCUMENT MUST BE PROCESSED SEQUENTIALLY BECAUSE THAT IS INTRINSIC TO THE FORMAT MAKING JSON A NON STARTER FOR A GPU
A LARGE PROJECT IN RUST REWRITE
A LITTLE BIT OF KNOWLEDGE WILL PROVIDE BACKGROUND INTO THE REFACTORING DECISIONS WE MADE AND LEAD US INTO DISCUSSIONS OF HOW WE REFACTORED THE ECS CODE
A LOT MORE SIGNIFICANT DIFFERENCES
A LOT OF THINGS I LEARNED ABOUT RUST I LEARNED FROM THEM AND I WOULD LIKE TO THANK EMBARK GIVING ME TIME TO DISCUSS THIS REPORT
A LOT OF US HAVE GOTTEN PRETTY GOOD AND GOTTEN A LOT OF PRACTICE WITH THE ALGORITHM IN OUR HEADS WITH AN ERROR MESSAGE
A LOT OF WORK MUST BE DONE TO MAKE SURE THAT THE STUDENT EXPERIENCE IS STILL GREAT
A REDUNDANCY SOLUTION LIKE THIS WILL PRODUCE A COMPRESSED FILE THAT IS FAR FROM OPTIMAL BECAUSE THE UNDERLYING PREDICTION THAT SEQUENCES OF BYTES REPEAT WOULD NOT HELP
A SELF INTROSPECTION AND OBSERVATION OF ONE'S PERCEPTIONS
A SIDE CHANNEL IS ANY ATTACK BASED ON INFORMATION GAINED FROM THE IMPLEMENTATION OF A CRYPTO SYSTEM NOT A WEAKNESS IN THE SYSTEM ITSELF
A SMALL NUMBER WHICH SOUNDS FAMILIAR WHEN WE LOOKED AT THE VARIABLE LENGTH ENCODING USED IN JSON
A SMART POINTER FOR THE REST OF THE LIST IN MY CONS
A SYSTEM THAT NEEDS TO SEND DATA TO OTHER SYSTEMS IT CAN INITIALIZE WITH THE DATA THAT NEEDS TO BE SENT
A TESTING LIBRARY RUNS ALL OF THE STUDENTS' UNIT TESTS WHILE AN ANIMATION LIBRARY EXECUTES THEIR CODE
A WILL BECOME A WILL GET THE VALUE OF B
A WORD OF CAUTION AND A GOOD OPPORTUNITY TO SHARE MY BIG ERROR NUMBER ONE
ABOUT THE PROGRAMS WE WRITE WE WRITE PROGRAMS THAT NEED TO MEET CERTAIN CONDITIONS SO THE COMPILER CAN ACTUALLY COMPILE THEM INTO WHAT WE WANT
ABOUT WHAT HARDWARE IT WILL RUN ON
ABSOLUTELY
ABSOLUTELY CALLED DIBS ON INTRODUCING AND BEING HERE FOR THIS TALK
ABSTRACT CLASSES ALLOW
ABSTRACT OVERHEAD IS EVERYWHERE
ACCESS TRIES TO USE WHAT ADVANCED TRAITS IN HOW YOU WOULD USE THE LIBRARY
ACTUALLY ACCESS WEB
ACTUALLY ALL OF THIS CODE ALL OF THESE THREE LINES ARE NOT REQUIRED TO BE DONE INSIDE AN UNSAFE FUNCTION
ACTUALLY IF THERE IS ONE THING YOU MUST GET FROM THIS TALK IT IS WHERE TO FIND HELP
ACTUALLY THE LIST OF THINGS THAT WAS CONSIDERED IMPORTANT RULES WHEN WE ARE DEALING WITH UNDEFINED BEHAVIOUR IS A LITTLE BIT TRICKY SO I'M JUST GOING TO MENTION SOME OF THEM
ACTUALLY THERE ARE SEVERAL UNIVERSITIES TEACHING RUST IN SEVERAL COURSES
AFFECT
AFFECTIONATELY CALLED FUNDIES2 BY THE STUDENTS
AFTER A FEW WEEKS OF CONSISTENT COLLABORATION ON THIS PROJECT I STARTED WORKING ON A FEW MORE FORMAL DOCUMENTS TO PUT THE LONGER TERM IDEAS IN MY HEAD ON TO PAPER
AFTER A WEEK I GAVE HER ENOUGH TRUST TO GIVE MAINTAINER PRIVILEGES TO NOT GO THROUGH ME
AFTER I HEARD ABOUT RUST MEMORY GUARANTEES I DECIDED TO LOOK INTO IT
AGAIN I CHECKED TO MAKE SURE THAT ALL OF THIS IS DONE PROPERLY WITH MY UNIT TESTS
AGAIN RUST DOESN'T HAVE A GREAT WAY OF
AGAIN WE HAVE THESE SUPER TINY PROGRAM USING AN EXTERNAL CRATE LET'S SAY THAT IS USING UNSAFE
AGAIN WITH A PLUS NAMING CALLED REPORT BORROWED VALUE DOES NOT LIVE LONG ENOUGH
AISSATA MAIGA LETS ME KNOW
AKI DO YOUR RUST STRUCTURES TOUCH OR MIRROR YOUR TYPESCRIPT TYPES IN YOUR BFF LAYER IN ANY WAYS
AKI HAS THE UNBREAKABLE WILL
ALL HAVE A HASHMAP OF DATA ABOUT WHAT TRAITS THEY DETECT
ALL IN ALL IT'S A GREAT TEACHING TOOL
ALL OF THIS WORK WAS DONE WHILE I WAS A MOZILLA EMPLOYEE AND IT IN NO WAY REFLECTS APPLE'S VIEWS
ALL PINS ARE INPUT BY DEFAULT AND THAT'S WHY YOU NEED TO CONFIGURE IT TO AN OUTPUT AND THEN YOU NEED TO DECLARE AN ECHO
ALL RIGHT
ALL RIGHT SO YOU'VE BEEN JOINED BY YOUR FRIEND TOO
ALL RIGHTY I THINK THAT'S ABOUT IT FOR QUESTIONS
ALL RIGHTY THEN
ALL THE COMPILERS TALK TO THE SAME LANGUAGE SERVER USING THE LANGUAGE SERVER PROTOCOL
ALL THE LIBRARIES AND THE IDE BUT WE CAN'T USE THAT IN RUST AND THAT IS WHERE AVR HAL HAS YOU COVERED
ALL THE PROJECT IS ON GITHUB SO PLEASE DON'T HESITATE TO DO WHATEVER YOU WANT WITH IT AND SHOW ME WHAT YOU DID
ALL THE TOOLS THAT MAKE THE RUST PROGRAMMING LANGUAGE ARE THERE
ALL THE WORK TO BUILD THIS DATA IS DONE FOR YOU BY OCHRE AND THEN SO I LIKE TO THINK OF THIS AS HUMBLE LIBRARY DESIGN WHERE YOU YOU RESPECT WHAT THE USER WANTS TO DO
ALL THESE COMMENTS ARE FOR THE MARKDOWN SO THAT IT IS EASIER
ALL THESE TOOLS SHOULD WORK WITH RUST
ALL THIS TO SAY YOU DON'T HAVE PERFECT ERROR MESSAGES IN RUST
ALL THOSE FUNCTIONS THAT INTERACT WITH C LIBRARIES ARE UNSAFE TOO
ALL YOU HAVE TO DO IS OPEN A CONSOLE IN YOUR WEB BROWSER AND YOU CAN START WRITING AND EXPERIMENTING WITH CODE
ALL YOUR DOCUMENTATION IS ANNOTATED ON TOP OF THE CODE SO THAT YOU DON'T HAVE TO DO IT SEPARATE
ALLOC AND STD
ALLOC DOESN'T TAKE A DEPENDENCE ON ANY LIBRARY
ALLOW FOR DEFINING DEFAULT BEHAVIOR INSTEAD OF JUST SHARED BEHAVIOR BETWEEN TYPES
ALLOW YOUR FIRST VERSION OF YOUR CODE TO BE INEFFICIENT
ALLOWING HER TO LOOK AT ISSUES BRANCHES PULL REQUESTS AND OTHERS IN THE REPOSITORY
ALMOST ALL OF THEM CAN BE BUILT IN THE WEBASSEMBLY SO WE CAN PARSE THE CODE AND EXTRACT THE INFORMATION THAT WE CAN USE TO SHOW HINTS TO OUR USER EVEN BEFORE THEY EXECUTE THEIR CODE
ALSO DATA DEPENDENCIES IN THE SERIALIZATION FORMAT PAUSE THE FLOW OF DATA THROUGH THE SYSTEM INCURRING THE LATENCY COST OF THE WIRES
ALSO EVERY TICK IS FOUR MILLISECONDS SO YOU WILL SEE A MULTIPLICATION BY FOUR THAT IS SUSPICIOUS
ALSO IF YOU ARE USING UNSAFE AND YOU ARE SUPER SURE YOU'RE NOT CAUSING UNDEFINED BEHAVIOUR YOU MIGHT ACTUALLY GET PERFORMANCE BENEFITS OR YOU CAN INTERACT WITH C LIBRARIES AND SO ON CORRECTLY IF YOU DON'T CAUSE UNDEFINED BEHAVIOUR THAT IS ALSO GOOD
ALSO IF YOU HAVE A POINTER THAT YOU OFFSET IT A BIT BUT YOU DIDN'T DO IT CORRECTLY I
ALSO IF YOU TRY TO PRODUCE A VALUE THAT IS INCORRECT FOR THEIR TYPE SO FOR EXAMPLE BOOLEANS WHEN YOU LOOK AT THE ACTUAL MEMORY LET'S SAY BOOLEANS ARE REPRESENTED BY BYTES
ALSO IT SEEMS THAT THE AMETHYST GAME ENGINE IN RECENT VERSIONS I'M NOT QUITE SURE IF IT'S RELEASED YET OR NOT THEY'RE MOVING ON TO A NEW ECS SYSTEM
ALWAYS ALWAYS ALWAYS
AN ASSEMBLER IS A TEXTUAL REPRESENTATION OF THE MACHINE CODE WE WERE TALKING ABOUT EARLIER
AN EXAMPLE OF MY BROKEN CODE
AN INTERRUPT IT'S A LOT LIKE A FUNCTION CALL
AN LED IS LIKE A TINY LIGHT
ANASTASIA PLAYS RUST LIKE A FLUTE
AND A COMPONENT ACTS LIKE A CONTAINER FOR DATA THAT CAN DESCRIBE AN ASPECT OF AN OBJECT
AND A DOES SOME THINGS AND CALLS INTO B
AND A FEW THINGS WERE ONCE AGAIN UNEXPECTED
AND ACTUALLY THE HANDLING FILES CAN DO A LOT OF STUFF
AND AFTER A COUPLE PRS GET LANDED FINALLY THE RUST BUG HAS BEEN FIXED
AND AFTER I DID THAT I STARTED TO WORK MORE WITH REFERENCES
AND AFTER I EDIT EACH OF THE FEATURES PRACTICED A LITTLE BIT DID SOME PERFECTION DID SOME CHANGES AND IN THIS WAY I WAS ALWAYS ABLE TO SLOWLY MOVE ALONG
AND AFTER THAT WE START INTERACTING WITH LLVM THAT IS FOR COMPILERS THAT RUST USES AND THE LLVM PROJECT HAS THEIR OWN INTERMEDIATE REPRESENTATION SO WE LOWERED MIR TO THE
AND AFTER THAT WHAT I FIND QUITE INTERESTING IS JUST SELECT SOME BOOKS AND THEN GO TO THE GITHUB REPOSITORY
AND AGAIN AS PROGRAMMERS WE HAVE TO KIND OF LEARN TO DECIPHER THEM
AND AGAIN MIRI CAN ONLY INTERPRET RUST PROGRAMS
AND AGAIN THE TAKEAWAY THERE NO SURPRISE REALLY BUT YOU KNOW BETTER ERROR MESSAGES LED TO A BETTER LEARNING EXPERIENCE AND A SMOOTHER LEARNING CURVE FOR STUDENTS
AND AGAIN THIS HAPPENS DURING THE BORROW CHECKING PHASE AND I DEFINITELY CANNOT TAKE A SCREENSHOT OF THE ENTIRETY OF THIS FUNCTION
AND AGAIN THIS IS NOT SOME SORT OF MAGIC BECAUSE EVEN IF WE DON'T HAVE AN IMMEDIATE ACCESS TO THE WEBASSEMBLY EXECUTION ENGINE IN THE BROWSER AND WE DON'T HAVE A KIND OF FINE GRAINED CONTROL OVER THE EXECUTION WE CAN TRANSFORM THROUGH THE COMPILATION STEP AND WE CAN DO THAT EVEN WITHOUT MODIFYING AND TALKING TO THE RUST COMPILER
AND AI LAST WITH A SCORE OF NEGATIVE 1
AND ALL OF THE HABITS THAT STUDENTS LEARN WITH RUST ARE APPLICABLE TO OTHER PROGRAMS LANGUAGES
AND ALLEGEDLY THERE WAS ONLY ONE DEVELOPER WHO DID THE ENTIRE SOFTWARE FOR THIS MACHINE
AND ALSO HAVING SORT OF AN INTEGRATED PACKAGE MANAGER IN RUST IS A GAME CHANGER
AND ALSO IN QUITE GOOD IDIOMATIC CODE
AND ALSO JUST INTERRUPTS ARE A BIT HARD TO IDENTIFY WHAT'S GOING ON
AND ANOTHER NICE THING ABOUT THE COLLABORATION WE WERE COMING INTO THIS KNOWING WE COULD LEARN SOMETHING FROM EACH OTHER
AND ANOTHER USER ASKS WHETHER YOU'VE HAD A LOOK AT THE BEVY ENGINE WHICH ALSO IS QUITE RECENT AND WHETHER YOU CAN COMMENT ON IT FROM THE USER PERSPECTIVE AN AMETHYST USER
AND ANY STATIC VARIABLES ANY STATIC
AND ANY TIME THAT WE NEED TO ASK THE PROCESSER TO DO WORK FOR US WE HAVE TO WRITE DOWN THE NUMBERS ON THE ETCH A SKETCHES AND GIVE THEM TO THE PROCESSER
AND AS A DEVELOPMENT TEAM HAVING A CRITICAL MASS OF RUSTACEANS IS CRITICALLY IMPORTANT BECAUSE IT ALLOWS US TO CREATE A COMMUNITY WITHIN THE DEVELOPMENT TEAM AND FOSTERING A CULTURE BECAUSE THE ECOSYSTEM IS CHANGING CONSTANTLY AND THE LANGUAGE IS ALWAYS EVOLVING
AND AS A SPECIAL TREAT I MEAN BESIDES THE AMAZING ENDING AISSATA IS HERE TO JOIN US FOR A LIVE Q AN A SO I'M GOING TO ADD HER ON NOW AND WE HAD A LOT OF QUESTIONS IN THE CHAT SO WE WILL TRY TO GET THROUGH AS MANY OF THOSE AS WE CAN
AND AS I MENTIONED BEFORE THIS IS WHAT OPERATING SYSTEMS AND BROWSERS HAVE BEEN MAKING A LOT OF USE OF GPUS FOR FOR A LONG TIME NOW
AND AS KIND OF EVIDENCE OF THIS BOTH MACOS AND WINDOWS HAVE BEEN USING GPU HARDWARE TO ACCURATE
AND AS WE WITH MANY ENGINEERS WE DON'T WRITE CODE JUST TO WRITE CODE BUT WE WRITE GOOD CODE TO MAKE A CHANGE
AND AT LAST WE PRINT ON THE SCREEN HOW FAR WE ARE FROM THE TARGET
AND AT THE END OF THE DAY DOING THAT REALLY HELPS NEW PEOPLE TRYING TO GET INTO YOUR LANGUAGE
AND AT THE END OUR FRAME POINTER WILL HAVE ITS ORIGINAL VALUE
AND BECAUSE IT IS INTERMEDIATE BETWEEN THE SOURCE AND MACHINE CODE THE LLVM AUTHORS HAVE DECIDED TO CALL IT INTERMEDIATE REPRESENTATION
AND BECAUSE OF THAT LLVMS ARE NOT ABLE TO OPTIMISE THROUGH THIS READ
AND BECAUSE OF THAT WE DECIDED TO MAKE THE DECISION TO CREATE SEPARATE SYSTEMS FOR THEM SO IT WAS EASIER TO MAINTAIN THE LOGIC THAT WAS SPECIFIC TO THOSE PARTICULAR EVENT TYPES
AND BEFORE THAT I NEED TO COMPILE LLVM WHICH IS ITSELF THE SUBJECT OF PERHAPS A FULL TALK
AND CAPABLE FUN
AND CHRISTIAN WILL GLADLY DEBATE'ER
AND CLIPPY SHOUT AT ME FOR MAKING A VARIABLE AND NEVER USING IT
AND CONNECT THE LOGICAL PINS TO THE ARDUINO
AND CRITICALLY AS YOU CAN SEE FROM THE DOCS HERE IT MAY NOT WORK
AND DO WE PLAN ON SELLING A VERSION OF THE GAME
AND DO WITH INTO EXACTLY WHAT THIS IS DOING A LITTLE BIT LATER
AND DUE TO THOSE TECHNICAL ISSUES WE'RE OF COURSE NOW A FEW MINUTES BEHIND FROM OUR
AND DURING EVERY STAGE THE ALGORITHM NEEDS TO PLACE 100 BRUSHES AND IT HAS TO DO SO IN 10 000 SEARCH STEPS
AND EACH OF THOSE DIFFERENT APIS HAVE DIFFERENT SHADING LANGUAGES
AND ECS IS VERY GOOD AT CONSTRAINING THE DATA AND SYSTEMS INTO BEING ORGANIZED WHICH IS REALLY NICE
AND ENTITY 2 HAS SIMILAR COMPONENTS AS WELL
AND ESPECIALLY EVEN MORE ME
AND ESPECIALLY FOR BEGINNERS I THINK THIS IS VERY HELPFUL
AND ESPECIALLY FOR ME AS SOMEONE WHO TEACHES NEOPHYTE PROGRAMMERS LIKE ERROR MESSAGES ARE VERY INTIMIDATING FOR NEWCOMERS
AND ESPECIALLY WHEN SORT OF RESEARCH IS SORT OF ON THE LINE BASED ON THESE RESULTS
AND EVEN BEFORE THAT THERE WAS ONLY AN OLDER VERSION WITH MORE LIMITED FEATURES WAS SUPPORTED
AND EVEN THERE WAS WELL I CHOOSE THE MOST BORING AND MAYBE EVEN INEFFICIENT ARCHITECTURES THAT COULD POSSIBLY WORK
AND EVERYTHING THAT WAS THERE WAS RATHER WELL TRANSPARENT AND EXPECTED
AND EXPLORE THE SHEEP NOT THE WAY WE SEE IT BUT INVITE TO EXPERIENCE THE CONCEPT OF A SHEEP THROUGH ITS HOOF MARKS AS IT WALKS ON THE CANVAS
AND EXTEND THEM INWARDS AND CONNECT THE SOURCE CODE INPUT TO THE RUSTC FRONT END
AND FINALLY A SYSTEM IS A PIECE OF LOGIC THAT CAN OPERATE ON ONE OR MORE ENTITIES IN HA GAME
AND FINALLY EXPLAINING COLLABORATION STRATEGIES TO PLAN AND EXECUTE THE REFACTORS WE DISCUSSED
AND FINALLY I REALIZED THAT RUST SO IT WAS IN CERTAIN PARTS THE HARDEST ONE TO LEARN BECAUSE OF MAKING SYNC
AND FINALLY I WOULD LIKE TO COVER SOME THINGS THAT ARE NON TECHNICAL
AND FINALLY I'M GONNA REMOVE THE MEMORY SHENANIGANS AROUND MY UNSAFE FAT STATIC MUTABLE BECAUSE I WANT TO ELIMINATE ANYTHING THAT COULD POSSIBLY DISTRACT FROM THE BUG
AND FINALLY LLVM DOES THE CODE GENERATION TO PRODUCE YOUR BINARY FILE OR YOUR LIBRARY AND SO ON
AND FINALLY RUST IS GOOD AT SOME THINGS AND NOT AS GOOD AT SOME OTHER THINGS SO MAKING SURE EVERYBODY IS AWARE OF HOW OUR DEVELOPMENT TEAM USES RUST AND WHERE WE CHOOSE NOT TO USE RUST
AND FINALLY THE BACKEND
AND FINALLY THE PERIPHERALS IN THIS METAPHOR ARE SOMETHING LIKE AN INTERCOM SITTING ON TOP OF THE DESK WHERE IF WE NEED TO CONNECT WITH THE OUTSIDE WORLD IF WE NEED TO INTERFACE WITH THE OUTSIDE WORLD ASK FOR A CUP OF COFFEE WE CAN PUSH THE BUTTON ON THE INTERCOM AND REQUEST SUPPORT
AND FINALLY THE SUCCESS OF THE RUST COMMUNITY CONTRIBUTES TO THE SUCCESS OF THE BUSINESS AND OUR DEVELOPMENT TEAM
AND FINALLY THERE'S BUILT IN DOCUMENTATION AND TESTING
AND FINALLY WE HAVE A STACK
AND FINALLY WE HAVE THE EPILOGUE FROM OUR WORKING
AND FINALLY YOU HAVE THINGS LIKE CONCERNS ABOUT A SINGLE VENDOR
AND FOR A LOT OF PEOPLE PROGRAMS ARE JUST A MEANS TO AN END
AND FOR EVERY COMPONENT IN A STORAGE THEY HAVE AN ENTITY ID THAT THEY ARE ASSOCIATED WITH
AND FOR HUNDREDS OF THOUSANDS OF LINES THAT BECOMES A REALLY SIGNIFICANT TIME SINK SO CSV LOAD HAS NOW BEEN MOVED COMPLETELY INTO RUST AND WE IMAGINE LARGE SCALE BULK OPERATIONS WILL ALL HAVE TO BE MOVED INTO RUST EVENTUALLY
AND FOR IMPLEMENTATION BLOCKS WE'RE GOING TO KEEP IT CLASSIC WITH INSTRUCTORS AND METHODS
AND FOR LINEARIZATION REPRESENTATION FOR CODEGEN
AND FOR ME AS SOMEONE WHO JUST WANTS TO WRITE THE CODE THIS IS 10 TIMES OR AN ORDER OF MAGNITUDE BETTER
AND FOUND AREWEGAMEYET RS
AND FUNCTION A IS JUST DOING SOME LOCAL THINGS
AND GIVEN THAT THE FIRST ONE IS THE DE REFERENCING RAW POINTERS I THINK IT'S WORTH TO DISCUSS RAW POINTERS FOR A MOMENT
AND HAVING THESE�EXAMPLES OF DIFFERENT WAYS TO DO THINGS OR BEING ABLE TO PULL A LOT OF DEPENDENCIES INTO YOUR PROJECT AND SORT OF EXPERIMENT WITH THEM I THINK IS ALSO A REALLY IMPORTANT FEATURE THAT RUST OFFERS AS A LANGUAGE
AND HAVING THIS
AND HAVING THIS ABILITY TO WRITE EXAMPLE CODE AND
AND HERE I'M SORT OF SKIPPING OVER A LOT OF OTHER LANGUAGES
AND HERE IS A GOOD SUGGESTED FIX
AND HERE IS A SCREENSHOT OF THE ISSUE IN LLVM'S BUG REPOSITORY
AND HERE IS A TIME AND QUALITY COMPARISON FOR CANNY VERSUS WITHOUT EDGE DETECTION
AND HERE IS THE ACTUAL BODY OF THE FUNCTION ITSELF
AND HERE OF COURSE THIS IS NOT OKAY
AND HERE WE CAN SEE A TRACE FROM A PROGRAM I WAS SIMULATING A FEW WEEKS AGO
AND HOPEFULLY IT IS NOT COMPLETELY MISLEADING
AND HOW COMPUTATIONAL DRAWING TRIES TO CAPTURE THAT SEARCH IN THE CONTEXT OF TRADITIONAL DRAWING FROM REFERENCE
AND HOW DO YOU DISCOVER THESE KINDS OF PROBLEMS AND HOW DO YOU EVEN BEGIN TO THINK OF A SOLUTION
AND HOW TO MAKE IT ACCESSIBLE TO EVERYONE
AND HTML AND CSS ARE
AND I
AND I ADD IN A LITTLE BIT OF
AND I ALSO HAD TO DEAL WITH QUITE A LOT OF SURPRISES
AND I ALWAYS HAVE TO STOP MYSELF LOOKING AT CRATE IO AND LOOK FOR THE MOST SUITABLE AND INTERESTING CRATE ANDWRITE A SIMPLE SOLUTION
AND I ALWAYS SAW THAT THE DIFFERENCE IS BETWEEN TRYING TO THINK ABOUT A HIKING TRIP ON A MAP AND SEEING IT IN REAL LIFE
AND I CAME UP WITH SIX THINGS
AND I CONTRIBUTE THAT TO LLVM
AND I COULD DROP A LINK TO IT IN THE SLIDES WHEN I RELEASE THOSE
AND I DIDN'T START OUT WITH RUST DIRECTLY BUT I WENT THROUGH DIFFERENT TECHNOLOGIES WHICH GAVE ME THE OPPORTUNITY TO WELL SEE HOW
AND I DO THIS BY COPYING MY WORKING VERSION OF THE CODE TO A FILE CALLED A DASH WORKING
AND I DON'T THINK I'M QUALIFIED TO TALK ABOUT IT
AND I DON'T THINK PEOPLE SHOULD BE REWRITING THEIR PROJECTS COMPLETELY
AND I DON'T WANT TO MINIMIZE THE ISSUES WITH THIS PROJECT
AND I GUESS ONE MORE SHOUTOUT FOR INSPIRATION HERE WALK THE DEAR IMGUI LIBRARY A UI RENDERING LIBRARY FOR C PLUS PLUS WHICH TAKES A VERY SIMILAR APPROACH AND IT'S BEEN USED IN VERY DIVERSE SCENARIOS INCLUDING THE CODEBASE FOR THE LARGE HADRON COLLIDER
AND I GUESS WHAT I MEAN BY THAT IS IS THERE JUST SOME CRAZY KIND OF LIKE ARCHITECTURE OR TECHNOLOGY OR ALGORITHMIC TRICK THAT IS GOING ON IN LIKE THE RUST COMPILER THAT MAKES THESE ERROR MESSAGES POSSIBLE OR MAKES THEM EASIER TO BE YOU KNOW CREATED WHEN SOMETHING GOES WRONG IN THE COMPILATION PROCESS INSIDE OF RUST C
AND I HAD TO LEARN HOW DIFFERENT COMPILERS AND DIFFERENT PLATFORMS WORKED
AND I HAVE SOME PAGES
AND I KNOW THAT AMETHYST THERE IS A POST THAT WAS MADE THAT AMETHYST IS WORKING WITH BEVY
AND I LIKE TO WRITE BLOG POSTS ABOUT EXPERIENCES IN SOFTWARE DEVELOPMENT
AND I LOVE PLAYING AROUND WITH HARDWARE
AND I MAKE THE SAME CHANGE TO BOTH OF THEM AND COMPILE THEM AND SEND THEM AND MAKE SURE THAT THE WORKING IS WORKING AND THE BROKEN IS BROKEN
AND I NEED THEM TO FINISH UP WHAT I'M DOING AND ASK THEM TO COUNT TO 20 AND LET ME KNOW WHEN I GET TO 20
AND I PACK THESE INTO AN ATLAS TEXTURE UPLOAD THAT TO THE GPU AND RENDER IT ALL USING TRIANGLES TO MAKE UP THOSE RECTANGLES
AND I PUT A LOT OF WORK INTO THIS AND THEN I DECIDED IT WASN'T THE APPROPRIATE APPROACH FOR UIS
AND I REACHED OCCUPANT OUT
AND I REALLY APPRECIATE YOU BEING HERE
AND I RECALL RESTORING THE FRAME POINTER IF WE DON'T NEED TO RESTORE A FRAME POINTER THE CODE WORKS
AND I RUN A MICRONOTE I TALK ABOUT MICROCONTROLLERS WITH PYTHON
AND I SAY THAT BECAUSE I KNOW THERE'S CONCERTED EFFORT THAT CONTINUALLY GOES INTO WORKING ON THOSE
AND I SEND THAT TO MY MICROCONTROLLER AND I TRY IT OUT
AND I SIT FOR A LITTLE BIT
AND I SIT ON IT FOR A BIT
AND I SORT OF SAID WHICH FEATURES DO I ACTUALLY NEED
AND I THINK ANOTHER FEATURE OF RUST THAT REALLY SORT OF IS GOOD FOR NUMERICAL PROGRAMMERS ESPECIALLY IS THAT FLOATING POINT NUMBERS ARE TREATED WITH A LOT OF CAUTION
AND I THINK HERE RUST REALLY STARTS TO SHINE AS A VIABLE ALTERNATIVE TO C PLUS PLUS BECAUSE YOU CAN ACHIEVE THE SAME OR VERY SIMILAR PERFORMANCE BUT WITH A KINDER SORT OF MORE GENTLE SYSTEMS PROGRAMMING LANGUAGE
AND I THINK KIND OF THE ONLY OTHER LANGUAGE THAT I WOULD ALSO SAY IS KIND OF IN THE SAME CLASS WOULD BE ELM
AND I THINK OTHER LANGUAGES CATER TO DIFFERENT AUDIENCES
AND I THINK THAT CHOOSING RUST IS GOING TO HAVE THE BIGGEST IMPACT ON SMALL RESOURCE CONSTRAINED TEAMS WHO DON'T IDENTIFY AS EXPERT SOFTWARE DEVELOPERS
AND I THINK THAT THAT'S GOOD
AND I THINK THESE TWO LANGUAGES IN PARTICULAR ARE DOING
AND I THINK THIS APPLIES TO LEARNING PROGRAMMING LANGUAGES
AND I THINK THIS IS A GOOD CHOICE IN A LOT OF CASES
AND I THINK THIS IS A VERY GOOD THING BECAUSE A LOT OF NEW PROGRAMMERS ESPECIALLY TODAY THEIR FIRST LANGUAGE IS PYTHON
AND I THINK THIS IS DEFINITELY THE CASE
AND I THINK THIS IS PROBABLY THE MOST IMPORTANT POINT FOR ME IS THAT IT'S A LANGUAGE EXPLICITLY DESIGNED FOR NON EXPERT USERS
AND I THINK THIS JUST GOES TO SHOW A LITTLE BIT THAT SOFTWARE BUGS DO HAVE REAL WORLD CONSEQUENCES
AND I TRIED TO JUST ALLOW MYSELF TO BE LESS CLEVER WITH MY CODE
AND I WANT BOTH OF THOSE THINGS AT ONCE
AND I WASN'T SURE IF I WOULD MAKE GOOD SUGGESTIONS ON HOW TO MAKE THE EXISTING CODEBASE DUE TO MY EXPERIENCE
AND I WILL ALSO SAY ONE THING THAT I THINK I'VE GOTTEN A LOT OF PRACTICE WITH TEACHING OVER ZOOM EVERY DAY IS I'VE GOTTEN REALLY GOOD AT IMAGINING THAT MY AUDIENCE ALWAYS LAUGHS AT MY JOKES
AND I WONDER WHO'S GONNA FIX IT
AND I WOULD ACTUALLY JUST GO AND POKE SOMEONE WHO I THOUGHT KNEW WHAT THEY WERE DOING AND ASK THEM LIKE HEY CAN YOU DECIPHER THIS FOR ME BECAUSE I'M TOO SCARED TO READ IT
AND I'M GONNA GET A LITTLE BIT MORE INTO HOW IT
AND I'M JUST GONNA USE THE EXAMPLE OF DATA RACES ARE THESE SORT OF CONCURRENCY ISSUES IN MULTITHREADING CODE
AND I'M USING A LINUX MACHINE BUT I'M GOING TO RUN IT FOR A TARGET THAT IS WINDOWS
AND I'M USING THIS ALL THE TIME
AND I'M WORKING AS A RADIATION MODELING RESEARCHER
AND I'VE DONE SOME MESSING AROUND WITH LLVM IN THE PAST
AND IF AN SHIM NEEDS TO INTERACT WITH THE OPERATING SYSTEM OR WITH ANY OF THE RESOURCES THAT THE STANDARD LIBRARY PROVIDES WE USE THE STANDARD LIBRARY FOR THAT
AND IF I HAD TO GO AHEAD AND KIND OF RANK DIFFERENT PROGRAMMING LANGUAGES KIND OF ON A TIER LIST OF THE QUALITY OF THEIR ERROR MESSAGES I WOULD PROBABLY GO AHEAD AND DO IT SOMETHING LIKE THIS WHERE I WOULD PUT RUST IN S TIER
AND IF IT IS IF IT SEES THAT THE CONDITIONAL VALUE IS TRUE IT JUMPS TO THIS INSTRUCTION SO IT SKIPS THIS COMPLETE INSTRUCTION
AND IF IT SEES THAT THAT IS ACTUALLY A CORRECT EXPRESSION OR AN EXPRESSION THAT MAKES SENSE THEN IT WILL GO AHEAD AND SURFACE THE ERROR OF OH THIS MAKES SENSE TO ME IF I PUT IN ANGLE BRACKETS SO THAT'S WHAT THE PROBLEM IS
AND IF IT'S IMPORTANT FOR YOU TO MAINTAIN WHAT WAS IN IT PREVIOUSLY THEN YOU HAVE TO SAVE AND RESTORE THAT REGISTER
AND IF ONE OF THEM IS AN INPUT YOU COULD PROVIDE A TRACE FILE THAT HAS THOSE INPUTS
AND IF THAT FUNCTION HAS A LOCAL VARIABLE WE NEED TO RESERVE SPACE ON THE STACK FRAME FOR THAT LOCAL VARIABLE
AND IF THAT'S EQUAL TO 3 WE'RE GOING TO PRINT OUT GOT 3
AND IF THIS CONDITIONAL VALUE IS FALSE THEN A SHOULD JUST REMAIN THE SAME VALUE AND B SHOULD JUST BE DROPPED BY THE WAY
AND IF THIS CONDITIONAL VALUE WAS FALSE THEN IT JUST DOES INSTRUCTION AND THEN MOVES UNDER THE INSTRUCTION AND THAT'S IT
AND IF YOU DON'T UNDERSTAND IT MOVE ON TO SOMETHING ELSE
AND IF YOU HAVE A POINTER TO A PARTICULAR MEMORY AREA YOU CAN ADD IT LIKE AN INTEGER AND YOU CAN OFFSET IT SO YOU CAN READ A PART OF THE MEMORY AND MAYBE YOU'RE NOT SUPPOSED TO
AND IF YOU WANT TO ANSWER MORE QUESTIONS YOU CAN HANG AROUND IN THE CHAT
AND IF YOU WANTED TO USE THE MOST ELEGANT SYNTAX AND DON'T REPEAT YOURSELF
AND IF YOU'RE AN ARTIST AND YOU ARE INTERESTING GETTING INTO RUST I REALLY RECOMMEND THAT YOU STOP CONSIDERING AND JUST DO IT
AND IN AND OUT TAKE REGISTER VALUES TO AND FROM SPECIAL REGISTERS FOR THE PURPOSE OF THIS TALK
AND IN DIFFERENT WAYS YOU COULD ARGUE THAT THEY SHOULD BE IN DIFFERENT ORDERS
AND IN EMBEDDED YOU TEND TO WRITE THINGS AS AN INFINITE LOOP
AND IN PARTICULAR I THINK DOCUMENTATION TESTS ARE REALLY A KILLER FEATURE FOR SCIENTIFIC CODE
AND IN SOME CASES IT'S LESS CAPABLE
AND IN THE CASE OF AN EARLY EXIT RESTORE THE STATUS REGISTER THEN
AND IN THIS CASE WE'RE TALKING ABOUT AN OUTPUT PIN TRAIT AND IT RETURNS A RESULT BECAUSE ON SOME PLATFORMS ATTEMPTING TO SET AN OUTPUT PIN CAN FAIL
AND INSIDE OUR PROCESSER WE HAVE AGAIN HAND WAVING QUITE A BIT HERE SOME MATH RELATED STUFF THAT'S GOING TO BE DOING ARITHMETIC PERHAPS
AND INSTEAD OF AS A WHOLE
AND IT ALLOWS YOU TO RUN A SIMULATION OF YOUR AVR PROGRAM
AND IT HAS THE SAME DISADVANTAGES AS TESSELLATION
AND IT HELPS TO THINK OF THE COLLECTIONS AS GROUND TOGETHER UNDER ONE ID
AND IT IS ABOUT 5 TIMES SLOWER THAN DOING IT WITH TWO RECTANGLES
AND IT IS AN UNSAFE FUNCTION AND MIRI CANNOT INTERPRET IT SO WHAT HAPPENS IF IN ANY OF THIS PROCESS WOULD BE WE HAVE UNDEFINED BEHAVIOUR
AND IT IS BECAUSE WELL YOU KNOW PROGRAMS DON'T RUN IN ISOLATION
AND IT IS SORT OF THIS MAYBE A LITTLE BIT OF A FRESH START FOR SOME PEOPLE
AND IT MIGHT ELIMINATE THAT ASSEMBLY DIRECTIVE COMPLETELY AND WE DON'T KNOW WE DON'T HAVE ANY GUARANTEE THAT THIS KIND OF STUFF WON'T HAPPEN IN THE FUTURE
AND IT POINTS A LOT OF HELPFUL ASCII ART HERE IS THE OFFENDING LINE HERE IS THE LOCATION
AND IT PRODUCES A FILE THAT IS LESS THAN ONE THIRD OF THE SIZE
AND IT TAKES MUCH LONGER WHEN DEVELOPING AN EMBEDDED FOR ME TO REALLY UNDERSTAND WHAT IT IS THAT'S MAKING IT WORK AND NOT WORK
AND IT WAS PART OF SIX MAJOR ACCIDENTS BETWEEN 1985 AND 1987
AND IT WAS SUPER REWARDING TO SEE PEOPLE GETTING INSPIRED AND TRYING OUT THEIR OWN VERSIONS
AND IT WAS UNORGANIZED DUE TO ME BEING NEW TO THE ECS ARCHITECTURE OF AMETHYST
AND IT WAS VERY SLOW TO CALCULATE LIKE A COUPLE OF HOURS ALMOST TO A DAY FOR ONE IMAGE
AND IT WILL STILL USE THE GPU EFFICIENTLY
AND IT WORKS
AND IT WORKS LIKE THE VECTOR TEXTURES ARCHITECTURE I MENTIONED EARLIER
AND IT'S A BIT OF A VAGUE GOAL
AND IT'S A REFINEMENT OF THE STENCIL AND COVER APPROACH THAT DOES A LOT OF THE CPU WORK SO YOU ONLY HAVE TO DO WORK NEAR THE EDGES RATHER THAN THE BIG PARTS OF THE SHAPE
AND IT'S A VERY COMMON PATTERN FOR PEOPLE TO USE
AND IT'S A VERY USEFUL THING
AND IT'S BASICALLY CHECKING
AND IT'S BEEN REALLY INTERESTING AS WELL SEEING SOME OTHER RESEARCH SPECIFICALLY AROUND KIND OF LIKE CULTURE AND ERROR MESSAGES AND HOW THE TWO KIND OF HAVE THIS FEEDBACK LOOP
AND IT'S GREAT SOMETIMES TO BE ABLE TO USE A DEBUGGER OR SOMETHING BUT LIKE AN ACTUAL GENERAL USE ALSO WHEN WE ARE DEVELOPING AND NOT DEVELOPING THE LOW LEVEL LIBRARY
AND IT'S IMPORTANT MORE SO THAN IN OTHER FIELDS THAT WE TRY AND MAKE SURE OUR PROGRAMS ARE AS BUG FREE AS POSSIBLE
AND IT'S IMPORTANT THAT THESE FRAGMENTS MIRROR EACH OTHER BECAUSE THEY TEND TO USE THE STACK TO IMPLEMENT THEIR
AND IT'S IMPORTANT THAT THEY'RE ABLE TO WRITE SOFTWARE IN A LANGUAGE THEY'RE COMFORTABLE WITH
AND IT'S NEVER A BUG IN THE COMPILER
AND IT'S NICE THAT IT'S CAUGHT RIGHT AWAY HERE
AND IT'S NOT CLEAR THAT WE WILL EVER REPLACE ALL OF PROLOG ALTHOUGH WE MAY
AND IT'S NOT IMPORTANT TO UNDERSTAND THIS IN DETAIL
AND IT'S PROBABLY INGENIOUS IN A SENSE
AND IT'S SORT OF A DIFFERENCE IN WHAT KIND OF CODE WE'RE COMFORTABLE WRITING
AND IT'S USUALLY A VERY GOOD THING WHEN YOUR PROGRAM RUNS QUICKLY
AND IT'S WHAT'S SORT OF CONTRIBUTES TO RUST BEING A MEMORY SAFE LANGUAGE
AND IT'S WORTH NOTING THAT ON AVR THAT INTERRUPT FLAG IS IN THE STATUS REGISTER WE WERE TALKING ABOUT EARLIER
AND ITEMS THAT SYNERGIZE RANDOMLY GENERATED LEVELS AND SATISFYING CONTROLS WITH PHYSICS
AND JUST BE EXTRA CAREFUL WHEN YOU'RE USING IT
AND JUST BY CHANGING REFERENCE TO
AND JUST CAN BE DIFFERENT
AND JUST LIKE MANY PAINTINGS ARE NOT A FAITHFUL REPRESENTATION OF REALITY SO IS COMPUTATIONAL DRAWING NOT MEANT TO BE A RECREATION OF AN ARTIST
AND JUST SOME REFERENCES AS WELL
AND LAST QUESTION
AND LASTLY A HELPFUL COMPILER GIVES STUDENTS A LOT OF GREAT FEEDBACK ABOUT WHAT EXACTLY IS GOING WRONG IN THEIR PROGRAMS
AND LASTLY THERE ARE SOME TOPICS THAT I'M LEAVING OUT FOR FUTURE CLASSES SUCH AS LIFETIMES
AND LASTLY WE HAVE COVERED THE ALGORITHM DETAILS AS WELL AS HOW WE CAN USE OUR ARTISTIC INTENT TO GUIDE THE SEARCH BY TRANSLATING IT INTO CODE
AND LATER ON IF YOU REALIZE THAT YOU NEED SOMETHING FASTER YOU CAN ALWAYS MOVE THERE
AND LET'S LOOK AT A COUPLE EXAMPLES
AND LET'S ONCE AGAIN CONNECT OUR ARROWS FOR OUR INPUT AND OUTPUT
AND LEVELS
AND LIKE I SAID THERE ARE MANY OTHER SPECIAL PURPOSE REGISTERS THAT WE WON'T BE TALKING ABOUT TODAY
AND LOOKS SIMILAR TO THE LLVM FLAG
AND MAKE THE INCREMENTAL CHANGES REPEATEDLY UNTIL IT LOOKS LIKE THE Y CASE X OR Y I GET TO Y AND I HAVE WHAT I THINK IS A MINIMAL REPRODUCTION
AND MAKES FOR A MUCH BETTER WORKFLOW I THINK
AND MAYBE PLAY AROUND WITH THIS EXAMPLE CODE A LITTLE MORE
AND MAYBE START
AND MAYBE THE PERSON THAT IS WRITING THIS PROGRAM DOESN'T KNOW ABOUT THE GARDEN AT THIS TIME THAT THAT CRATE HAS TO BE SURE THAT THESE FUNCTIONS DON'T CAUSE UNDEFINED BEHAVIOUR
AND MORE SPECIFICALLY I THINK THE CULTURE OF THE COMMUNITY IS WHAT INFORMS THE TECHNOLOGY THAT WE HAVE GOING ON IN THIS CASE
AND MOST IMPORTANTLY I'M GOING TO BE OVERSIMPLIFYING BECAUSE I WOULD LIKE TO COVER A LOT OF MATERIAL
AND MOVING FORWARD IT JUST RECEIVING A MUTABLE REFERENCE TO WHEELS
AND MY KIDS WANT ME TO COME IN AND PLAY WITH THEM
AND NEXT SESSION STARTING IN 10 MINUTES
AND NOBODY COMMENTS ON IT
AND NOT FOLDED DIRECTLY INTO THE STANDARD LIBRARY
AND NOTABLY THE
AND NOTHING
AND NOW A TO CARLO WHO WILL BE GIVING A SUMMARY OF SPACE SHOOTER
AND NOW IS A GOOD TIME TO SHARE A BIG ERROR NUMBER TWO ON THE MICRO CONTROL THE TIMERS DO NOT ALL HAVE THE SAME SIZE YOU MUST MAKE SURE THAT YOU ARE DOING THE CALCULATION WITH THE RIGHT TIMER OR THE RIGHT SIZE
AND NOW THAT I'VE WORKED THROUGH STEPPING THROUGH THE ASSEMBLE HER THAT'S GENERATED AND WORKING THROUGH THE CODE THAT GENERATES THAT ASSEMBLER I FEEL A LITTLE BIT OF A RESPONSIBILITY TO TAKE A LOOK AT THESE BUGS
AND NOW THE PROBLEMS THAT WE WERE HAVING
AND NOW TO CARLO WHERE HE WILL EXPLAIN THE ORIGIN OF SPACE SHOOTER RS
AND NOW TO CARLO WHO WILL EXPLAIN HOW CREATING INFORMAL DOCUMENTATION HELPED WITH COMMUNICATING THE STATE OF THE SPACE SHOOTER PROJECT TO HELP ONBOARD ME ON TO THE PROJECT
AND NOW TO CONCLUDE THE TALK
AND NOW TO MICAH TALK ABOUT THE ENTITY STRUCTURE
AND NOW TO WEEKLY MEETINGS
AND NOW WE'VE REACHED A REALLY INTERESTING POINT
AND OF COURSE AS WE SAW IN THE MODEL PREVIOUSLY THE WORLD HERE IS THE PERIPHERALS
AND OF COURSE DOWN BELOW YOU CAN SEE I HAD UNIT TESTS TO MAKE SURE EVERYTHING WORKS AS PROPERLY
AND OF COURSE OUR BELOVED GAMING RIGS WITH THE METAL POWER SUPPLIES AND THE CASES ALL MADE OUT OF SHEET METAL BENT AND CUT INTO JUST THE RIGHT SHAPES
AND OF COURSE THIS IS A BUG
AND OF COURSE THIS IS GONNA GIVE US A GARBAGE ANSWER
AND OF COURSE YOU CAN SORT FLOATING POINT NUMBERS IN RUST
AND OF THOSE 20% CRATES ALL THOSE CRATES 74% OF THEM DO UNSAFE CALLS TO FUNCTIONS THAT AREN'T IN THE SAME CRATE SO OUR CRATES THAT ARE USING UNSAFE TO CALL FUNCTIONS THAT ARE EITHER IN THE STANDARD LIBRARY OR IN OTHER CRATES
AND OFTENTIMES THE CONVENIENT THING OR THE THING PEOPLE DEFAULT TO IS THE SAFE METHOD
AND OKAY THERE IS ALSO SOMETHING INTERESTING AND IT'S THAT SOME OF THE CODE THAT'S USED IN MIRI IS USED IN THE ENGINE THAT DOES COMPILE TIME FUNCTION EVALUATION
AND ON AND OFF
AND ON THE RIGHT OUR TWO BOXES ARE CALLED PROCESSER AND PERIPHERALS
AND ON THIS SIDE WE CAN SEE AN EXAMPLE FROM THE RUST STANDARD LIBRARY DOCUMENTATION TO INSTRUCT THE ENUMERATORS IN A FUNCTIONAL STYLE AND WHILE IT MAKES SOME SENSE IT'S HARD TO SEE WHAT KIND OF OUTPUT WE WILL GET WHEN FOR EXAMPLE WE CALL THE FILTER FUNCTION ON THE THIRD LINE
AND ONCE WE HAVE NEW HIRES TRAINING THEM HAS BEEN REQUIRED NEW KINDS OF EFFORTS BECAUSE SOMETIMES RELEARNING NEW FOUNDATIONAL CONCEPTS AND LEARNING TO TALK WITH THE COMPILER
AND ONCE YOU START LEARNING FOCUS ON THE LANGUAGE
AND ONE OF THE METHODS IN THE DIAGNOSTIC CLASS IS THIS CANCEL METHOD
AND ONE OF THE REASONS TO LIMIT THE STEP NUMBER IS TO ENCOURAGE HAPPY ACCIDENTS MISTAKES AND IMPERFECTIONS
AND ONLY THEN SLOWLY MOVED ON TO MORE WORK AND MORE COMPLEX THINGS THAT I NEEDED FOR MY APPLICATION BACKEND
AND OTHERWISE RESTORE THE STATUS REGISTER AT THE VERY END
AND OUR CODE ON THE WEB TO BEHAVE
AND OUR PROGRAM IS THE RUST SOURCE CODE FOR
AND OVERALL AT THE END OF THE DAY I THINK THAT WOULD BE SUPER GREAT FOR EVERYBODY
AND PREVIOUSLY MENTIONED THIS TALK IS ABOUT MY EXPERIENCES FINDING AND FIXING A BUG WITHIN THE RUST COMPILER
AND PUT IT INTO A GENERAL PURPOSE REGISTER
AND PYTHON IS EXTREMELY GOOD AT HIDING COMPLEX LIBRARIES FROM THE USER
AND QUITE OFTEN THERE IS NO ONE REPRESENTATION THAT JUST WORKS FOR A AND IT BECOMES AN ITERATIVE SEARCH FOR PIECES NEEDED TO DESIGN A NEW PRESENTATION
AND RECENTLY HARDWARE AND RUST
AND REMOVING FRICTION MEANS THAT PEOPLE ARE GONNA DO IT A LOT MORE AND IT'S SORT OF AN EASIER TOOL TO DO
AND RENDERING HAPPENS TO A LOT OF ASPECTS OF TWO D RENDERING HAPPEN TO BE HIGHLY PARALLEL
AND REPRESENTING OUR BRUSH CONFIGURATION AS ONE DIMENSION IT IS JUST A MENTAL SHORT CUT IN FACT THAT ONE DIMENSION ENCAPSULATES FIVE SCALE ROTATION VALUE AND POSITION OF X AND Y
AND RESEARCH YOU CAN STAY MOTIVATED
AND RESEARCHER TIME IS USUALLY VERY PRECIOUS
AND RESUME WORK ON MY BOSS' CLIENT
AND RETURNS A STRING
AND RUST ACTUALLY ALLOWS YOU TO START SLOW
AND RUST AIN'T NO CONTRADICTION
AND RUST DOCUMENTATION DOES A REALLY GOOD JOB OF SAYING THIS IS ACTUALLY NOT RECOMMENDED
AND RUST DOES A REALLY GOOD JOB HERE
AND RUST DOES TOO
AND RUST EARLY ON DEFINITELY MADE THAT A PRIORITY AND MADE THAT A VERY
AND RUST HAS AN UNSTABLE FEATURE CALLED GENERATORS AND THIS IS USED FOR USING THE ASYNC AWAIT SYNTAX
AND RUST IS DOING A GOOD JOB AND SAYING THAT FLOATING POINT TYPES CANNOT BE USED IN PATTERNS BECAUSE THIS IS NOT A VERY GOOD WAY OF DOING THINGS
AND RUST IS STOPPING US AND SAYING THERE'S MISMATCHED TYPES HERE
AND RUST WILL SAY YOU KNOW GO AHEAD NO PROBLEM
AND RUST'S PLACE IN SCIENTIFIC COMPUTING IS A LANGUAGE WITH THE SPEED AND POWER OF C PLUS PLUS
AND RUST'S WAY OF DOING THIS IS IS USING THESE UNSAFE BLOCKS
AND SECOND OUR IMPRESSIONS OF THE LIBRARY ECOSYSTEM
AND SEE IF YOU UNDERSTAND IT OR NOT
AND SHARING IDEAS
AND SHARING IDEAS REGULARLY KEEPS EVERYONE ON THE SAME PAGE
AND SIGNING THE CODE TO SUBMIT IT TO APP STORES WAS WELL NOT REALLY NICE
AND SINCE I'M ON THE TRAIT SYSTEM I COULDN'T JUST GO AND SEE OKAY THIS IS HOW THIS IS SUPPOSED TO WORK
AND SINCE IT WAS THE TWO OF US WE COULD MAKE MISTAKES AND LEARN FROM THEM
AND SINCE RUST DOESN'T REALLY ALLOW ANY WORK AROUNDS FOR ERROR HANDLING STUDENTS ALWAYS MUST HANDLE THIS
AND SINCE THIS IS A RUST CONFERENCE OUR COMPILER PRESUMABLY IS RUSTC THE RUST COMPILER
AND SO ACTUALLY SOME OF THE STUFF THAT
AND SO AGAIN WE CAN SEE THERE'S A NICE KIND OF ONE TO ONE MAPPING OF EVERYTHING WE JUST SAW IN THAT KIND OF STANDARD ERROR MESSAGE FORMAT
AND SO AN EXAMPLE LIKE THIS WHERE WE'RE GOING AHEAD AND TRYING TO PUSH A COUPLE OF REFERENCES TO SOME VECTOR
AND SO BEAR WITH ME
AND SO FOR EXAMPLE THERE IS THIS THING THAT LVM COULD DO WHICH IS ELIMINATE ANY CONDITIONAL MOVES THAT MAY LOAD
AND SO I ALSO HAVE GOOD NEWS ACTUALLY THE BEST NEWS
AND SO I APPRECIATE THAT
AND SO I DECIDED TO SHARE MY LEARNINGS AT RUST CONF THIS YEAR WHERE IT HELPED SOLIDIFY MY KNOWLEDGE ABOUT THE TOPIC
AND SO I LOOKED MORE INTO THE LANGUAGE AND STARTED WRITING PROJECTS IN IT
AND SO I USE THIS INCANTATION RUSTFLAGS = EMIT = LLVM IR
AND SO I WANT TO REDUCE THE AMOUNT OF MACROS THAT WE USE AS MUCH AS POSSIBLE
AND SO I'M MAKING A BUNCH OF CHANGES
AND SO I'VE CONFIRMED A BUG
AND SO IT'S A BIT LIKE A STALACTITE HANGING FROM THE ROOF OF A CAVERN
AND SO NOW THE FIRST
AND SO NOW WE'VE JUMPED INTO OUR INTERRUPT SERVICE ROUTINE
AND SO ONLINE 3 WE TOGGLE OUR LED
AND SO SOMETIMES THIS CAN BE A LITTLE BIT ANNOYING
AND SO STUDENTS AREN'T ALREADY FAMILIAR WITH THIS IDEA
AND SO THAT MEANS I HAVE TO COMPILE WITH THE RUST NIGHTLY AND ADD A FEATURE FLAG AND ALL OF THOSE SORT OF ADD CONFOUNDING FACTORS TO THE DEBUGGING PROCESS
AND SO THAT'S
AND SO THE ASSEMBLY DIRECTIVE DOESN'T WORK ON STABLE RUST BECAUSE FOR THE ASSEMBLY DERIVE YOU NEED TO HAVE A NIGHTLY RUST VERSION TO COMPILE SO THAT IS NOT REALLY OPTIMAL
AND SO THE DOCUMENTATION
AND SO THE FIRST IDEA OF LEARNING RUST
AND SO THE OTHER TRICK THAT WE CAN USE IS TO DO A VOLATILE READ OF SECRET DATA
AND SO THE THING THAT SETS RUST APART IS THAT SOFTWARE ENGINEERING BEST PRACTICES ARE BUILT INTO THE LANGUAGE IN CORE TOOLS
AND SO THERE'S NOT REALLY
AND SO THEY MUST LEARN HOW TO RESPECT IT IN OBJECT ORIENTED PROGRAMMING
AND SO THIS GOES BACK TO
AND SO THIS IS A BIT OF A COMMON BEGINNER MISTAKE
AND SO THIS IS SOMETHING THAT WE'LL HAVE TO FIND A WORK AROUND FOR LATER
AND SO THIS IS YOU KNOW A LITTLE BIT NOISY UP FRONT
AND SO THIS RESULT CAN NEVER BE THE ERROR CASE
AND SO WE CALL IT MACHINE CODE
AND SO WE CAN SEE KIND OF UP HERE AT THIS TYPE
AND SO WE HAVE TO IMPLEMENT OUR OWN OBJECT WHICH WILL ALLOW US TO DO THIS OURSELVES
AND SO WE WANT TO KNOW WHAT WAS ON IT BEFORE WE ERASE IT SO THAT WE CAN PUT IT BACK ON
AND SO WE'RE GONNA DO THAT FIRST
AND SO WHAT I MEAN BY THAT IS WELL BOTH
AND SO WHAT WE OBSERVE IS THAT DATASETS CONTAINING ARRAYS ARE OFTEN PREDICTABLE
AND SO WHEN WE'RE DONE WITH
AND SO WITH RUST MONADIC OPTION TYPE AND RESULT TYPE I THINK THAT THAT'S A GREAT WAY TO KIND OF MAKE SURE THAT STUDENTS ARE ALWAYS BUILDING THAT HABIT
AND SO YEAH I THINK IT'S A GOOD
AND SO YOU CAN SEE THE STATE OF THOSE FIVE PINS
AND SO YOU KNOW COMING UP WITH SEARCH RESULTS ON AVR FREAKS IS FANTASTIC
AND SO YOU KNOW HE TOOK A COUPLE OF WEEKS WHICH IS TO SAY LIKE IT
AND SO YOU KNOW THIS WAS DONE IN 2011 BUT I THINK REALLY THE TAKEAWAY OF THIS PARTICULAR RESEARCH WAS WELL YOU KNOW IT'S NOT A QUESTION OF TECHNOLOGY
AND SOME OF THE DEFINING CHARACTERISTICS ARE OF THIS IDEA ARE SEEING THE STATE OF A RUNNING PROGRAM AND GIVING THE PROGRAMMER TOOLS TO EASILY PLAY WITH THEIR CODE
AND SOME OF THE THINGS THAT MAKE THE BUG APPEAR AND DISAPPEAR ARE MOVING MY INTERRUPT SERVICE ROUTINE CODE INTO MAIN
AND SOME PROGRAM CONTROL STUFF THAT LETS US DO LOOPS AND CONDITIONAL JUMPS AND MOVING AROUND IN OUR PROGRAM
AND SOMETIMES IN ORDER TO GET TO THIS POINT WHERE WE WELL WRITE THE BEST CODE WE COULD POSSIBLY THINK ABOUT WE CHALLENGE OURSELVES TOO MUCH
AND SOMETIMES SORT OF GOOD SOFTWARE ENGINEERING PRACTICES ARE THROWN OUT THE WINDOW
AND SOMETIMES THIS IS ACTUALLY A VERY DIFFICULT THING TO DO IN PYTHON
AND SORT OF MORE INTO A CORRECT WAY OF DOING THINGS
AND SORT OF THE ISSUES WITH IT
AND SORT OF THE NATURAL DEFAULT WAY OF USING THESE BRACKETS TO ACCESS THE ELEMENT IS SORT OF THE SAFE DEFAULT WAY
AND SPECIFICALLY IN THE CASE OF THIS ERROR MESSAGE AGAIN IT HAPPENS DURING THE PARSING PHASE AND IF WE'RE TO KIND OF FOLLOW THAT TRAIL DOWN INTO RUST C WE CAN SEE THAT INSIDE OF THIS FUNCTION THAT HAPPENS AGAIN DURING PARSING THIS PARSE SUFFIX FUNCTION DOWN HERE WE CAN SEE THIS FUNCTION HERE THAT'S CALLED CHECK TURBOFISH MISSING ANGLE BRACKETS
AND SPOILER IT'S IN THE TITLE OF THIS TALK IT'S CALLED MIRI
AND SUBTRACT 1 FROM IT AND SEND THAT BACK OUT TO THE FRAME POINTER
AND SUPPORT FOR AVR WAS MAINLINED INTO THE RUST COMPILER THIS PAST SUMMER
AND THANK YOU FOR ATTENDING OUR TALK
AND THANKS SO MUCH TO EVERYONE WHO PUT ON THIS WONDERFUL CONFERENCE AND GIVING ME THE OPPORTUNITY TO GIVE THIS TALK
AND THAT ANALYSIS IS SIGNIFICANTLY HARDER TO DO IF YOU'RE USING THE HEAP
AND THAT DOESN'T HAVE THE SAME GUARANTEES THAT IT HAS ABOUT SAFETY AND HAVING SOUND PROGRAMS AND SO ON
AND THAT GAVE ME A ROUGH IDEA ON HOW I WOULD HAVE TO MOVE ALONG
AND THAT IS ALL FROM ME AND THANKS FOR YOUR ATTENTION AND I WILL BE ANSWERING YOUR QUESTIONS IN THE CHAT ROOM
AND THAT IS WHAT COMPUTATIONAL DRAWING AIMS TO CAPTURE
AND THAT LEAVES ONE BIG GAP
AND THAT MATCHES UP TO OUR
AND THAT MEANS USING MORE COMPUTING POWER
AND THAT OF C PLUS PLUS JUST BECAUSE IT'S YOUNGER
AND THAT PERSON IS THE BRAINS OF THE OPERATION AND THAT'S ANALOGOUS TO THE PROMOTER
AND THAT PROGRAM WILL MAKE THE LIGHT TURN ON AND OFF
AND THAT WAS BASED ON WELL SWIFT JAVASCRIPT AND RUST IN THE BACKEND
AND THAT'S A PLACE WHERE BEING ABLE TO USE FOR INSTANCE A SLAB ALLOCATOR ON A PER OBJECT BASIS WOULD BE INCREDIBLY VALUABLE
AND THAT'S ALMOST ALL OF THE TALK
AND THAT'S ALWAYS UNSAFE
AND THAT'S EXACTLY WHAT THIS MAKES ME THINK OF RIGHT
AND THAT'S FOR SOME IMPORTANT REASONS
AND THAT'S GOING TO
AND THAT'S IT
AND THAT'S SORT OF THE NESTED CONTEXT VIEW OF THE STACK
AND THAT'S THE WHOLE PROBLEM
AND THAT'S WHAT A LOT OF SOFTWARE DEVELOPERS IDENTIFY AS
AND THAT'S WHAT AN LLVM ALLOCA INSTRUCTION DOES
AND THAT'S WHAT LEADS TO OUR POPS
AND THAT'S WHEN I FIRST DISCOVERED THIS FOR MYSELF SO YES
AND THE ANIMAL SHARED IMPLEMENTATION WE HAVE TO CHECK TO MAKE SURE THAT THE WEIGHT IS NON NEGATIVE
AND THE BEHAVIOUR LIKE OR THE RUNTIME OF A PROGRAM OR STUFF LIKE THAT IS NOT CONSIDERED TO CHANGE THE PROGRAM IN THE VIEW OF A COMPILER SO THE COMPILER MIGHT ACTUALLY OPTIMISE STUFF THAT WE DON'T THINK WOULD BE SHOULD BE POSSIBLE
AND THE BIG DIFFERENCE IN EMBEDDED IS THAT IT'S SLOWER
AND THE BIG QUESTION NOW IS WELL ACTUALLY WHAT CAN GO WRONG WHEN YOU USE UNSAFE
AND THE BROKEN VERSION TO A FILE CALLED A DASH BROKEN
AND THE CALLING CONVENTION SAYS SOME OF THE WORKING REGISTERS NEED TO BE SAVED BY THE FUNCTION THAT CALLS
AND THE CODE IS MAYBE LESS NICE LESS IDIOMATIC THAN IT COULD BE
AND THE COMPILER MIGHT CHANGE IN THE FUTURE
AND THE FILTER METHOD WE HAVE THE SAME THING AS COUNT EXCEPT FIRST WE CHECK TO SEE IF THE PREDICATE IS SATISFIED BY THE FIRST IN THE LIST
AND THE FIRST ONE IS CALLED THE STATUS REGISTER
AND THE FIRST THING I DO BEFORE I WRITE IT IS JUST PROGRAM IT IN C OR RUST AND SEE WHAT THE COMPILER TELLS ME TO DO
AND THE GOOD NEWS IS THAT A LOT OF CROSS LIBRARIES ALREADY DO SOMETHING LIKE THAT WITH TRACING AND LOGGING BUT TO USE THAT YOU ALSO HAVE TO CHOOSE A LOGGING LIBRARY AND ENABLE IT TO JUST GET THE LOG OUTPUT
AND THE IDEA HERE IS YOU TAKE A MICROCONTROLLER
AND THE IDEA IS THAT I CAN WRITE AN EXAMPLE THAT WHEN I PUSH THE BUTTON IT WILL BLINK THE LIGHT ON AND OFF
AND THE INPUT REPRESENTATION WE ALREADY CALLED IT SOURCE CODE
AND THE INPUT TO OUR COMPUTER IS SOME KIND OF PROGRAM
AND THE INSTRUCTORS DO A GREAT JOB OF MAKING SURE THEY ONLY LEARN THAT LATER ON IN THEIR EDUCATION
AND THE LAST TIME ARE THE LARGER PROJECT GOALS THAT RELATE TO SPACE SHOOTER RS AS A PROJECT
AND THE MAIN DIFFERENCE IS THAT WE HAVE THIS ONE ALLOCA
AND THE MECHANISM THAT RUST USES TO INTERACT WITH THOSE ARE FOR FOREIGN FUNCTIONS
AND THE MINIMAL DIFFERENCE HERE LOOKS A LOT LIKE MY
AND THE MOST IMPORTANT DIFFERENCE FOR THE MEMORY IN AN EMBEDDED CONTEXT IS THAT IT'S MUCH
AND THE NEXT SESSION IS STARTING IN 10 MINUTES I BELIEVE
AND THE NEXT WERE THE MVPS FOR THE PROJECT
AND THE ONLY REASON WE ARE SAVING THEM HERE IS BECAUSE WE'RE IN AN INTERRUPT
AND THE ONLY WAY TO WORK AROUND THAT EASILY WAS TO INTRODUCE HEAP ALLOCATION
AND THE OTHER ASPECT IS TAKING MULTIPLE SHAPES LIKE THAT AND COMPOSITING THEM IN ORDER USING WHAT'S CALLED THE PAINTER'S ALGORITHM
AND THE OTHER IMPORTANT POINT IS THAT MIRI CAN ONLY DETECT UNDEFINED BEHAVIOUR AS IT IS HAPPENING
AND THE OUTPUT OF OUR LLVM BACKEND IS OUR MACHINE CODE
AND THE OUTPUT REPRESENTATION IS THE ONE THAT'S MEANT FOR THE MACHINE THE COMPUTER MACHINE
AND THE OUTPUT WILL SAY
AND THE PRIMARY USE CASE THAT I'VE INTENDED OCHRE FOR IS UI RENDERING
AND THE PROGRAM IS THE INPUT TO THE COMPILER
AND THE REASON I THINK OF IT THIS WAY IS THAT IN MOST
AND THE REASON WE DO THAT IT BECAUSE WE WANT TO ANALYZE THIS COMPLEX SYSTEM NO TERMS OF THE DETAILS OF THE INSIDE THE IMPLEMENTATION BUT RATHER IN TERMS OF ITS INPUTS AND ITS OUTPUTS
AND THE RECEPTION WAS BEYOND MY EXPECTATIONS
AND THE RUST COMPILER AND THE ABILITY FOR THE MATCH STATEMENT TO TELL US WHEN WE ARE MISSING THINGS HAS ACTUALLY SAVED US MANY MANY TIMES
AND THE RUST COMPILER CONTRIBUTORS ARE WORKING SO HARD TO MAKE RUST A VIABLE OPTION FOR EMBEDDED
AND THE RUST COMPILER HAS A FLAG TO EMIT ASSEMBLER AS WELL
AND THE RUST COMPILER�DUTIFULLY COMPLIES AND EMITS LLVM
AND THE SAYING IS THAT A LOT OF TIMES THE RIGHT TOOL FOR THE JOB IS THE ONE YOU'RE ALREADY USING
AND THE SECOND THING IS BECAUSE THE FUNCTION THAT'S GETTING INTERRUPTED DOESN'T KNOW THAT IT'S GOING TO BE INTERRUPTED IT CAN'T PERFORM STEP FIRST
AND THE SOURCE CODE IS ALSO ON GITHUB
AND THE SOURCE CODE IS THE INPUT TO OUR FRONT END
AND THE STUFF THAT YOU NEED TO LEARN ABOUT MIRI IS REALLY SMALL
AND THE THING THEY FOUND REALLY INTERESTING FROM THIS PARTICULAR BLOG POST IS THAT HE SAYS I RECENTLY TOOK A COUPLE OF WEEKS TO REALLY FOCUS ON THIS BEING
AND THE THING TO NOTE HERE IS THAT IT'S
AND THE THING WITH RUST IS THAT THE LANGUAGE ITSELF THE CONCEPTS ET CETERA ARE QUITE CHALLENGING TO LEARN
AND THE TYPE OR THE STRUCTURE THAT DEALS WITH THIS AT THE END OF THE DAY INSIDE OF RUSTC ITSELF IS THIS DIAGNOSTIC TYPE
AND THE USER'S CODE CAN ALSO BE SEEN AS DATA THAT WE CAN VISUALISE AND INSPECT AND SOME OF THE COMPONENTS OF THE RUST COMPILER ARE ALREADY AVAILABLE AS LIBRARIES AND THERE ARE EVEN SOME FOR CREATES THAT CAN BE USED FOR PARSING THE RUST CODE
AND THE VARIOUS RULES
AND THE WAY IT WORKS IS IT ONLY RENDERS THE PIXELS THAT ARE INTERSECTED BY THE OUTLINES
AND THEN A SECOND AND THIRD SECTION WITH POPS AND OUT
AND THEN AFTER MIRI INSTALLS IT DOES SOME ADDITIONAL STUFF IT TAKES A WHILE COMPILING BUT YOU CAN RUN BINARIES
AND THEN AS WE RESUME PREVIOUS CONTEXT WE SHRINK IT BACK UP
AND THEN BECAUSE LLVM CAN JUST ANALYSE THROUGH THIS MASK VARIABLE IT CAN DO THIS REALLY NICE OPTIMISATION OF ADDING A BRANCH AND THEN JUST ELIMINATING ALL THESE BITWISE OPERATIONS
AND THEN BEYOND THAT MOST OS PLATFORM UI TOOLKITS AND CROSS PLATFORM UI TOOLKITS ALL USE
AND THEN FINALLY LAST ON THE LIST WE HAVE A PURE GPU COMPUTE RENDERER
AND THEN I SEE THAT IN EIGHT MINUTES WOULD BE WILL HE START THE NEXT SPEAKER ALREADY
AND THEN I SUBMIT THE PATCH TO LLVM
AND THEN IF THIS CONDITIONAL VALUE WAS FALSE AND THEN THIS MASK WOULD BE ALL ZEROS
AND THEN IN AN INFINITE LOOP WE ARE GOING TO WRITE ZERO TO THE TIMER SET THE TRIGGER HIGH FOR TEN MICROSECONDS AND SET THE TRIGGER LOW AGAIN
AND THEN IT
AND THEN IT UPLOADS THOSE AT HORIZONTAL LINES THE GPU
AND THEN IT WORKS AND I HAVE NO IDEA WHY
AND THEN JUST GO OVER THE EXAMPLE OF CODE
AND THEN KIND OF EVERYTHING ELSE GOING DOWN
AND THEN LET YOU KNOW WHEN IT GETS TO THAT NUMBER
AND THEN MY BOSS COMES IN AND IS HOLDING THE FILE FOLDER FOR A CLIENT THAT'S MORE CRITICAL
AND THEN NOTES AS WELL AS ANY SUB DIAGNOSTICS TO TRY TO BE HELPFUL AND PROVIDE YOU WITH A LITTLE BIT MORE CONTEXT AS TO WHAT
AND THEN OF COURSE IN JAVASCRIPT I JUST WANTED TO BRING THIS ONE UP IN PARTICULAR BECAUSE YOU GET THE INFAMOUS UNDEFINED IS NOT A FUNCTION ERROR MESSAGE THAT IS SO UNHELPFUL
AND THEN OF COURSE YOU HAVE THE MAIN ERROR MESSAGE THE LOCATION THE CODE IN QUESTION ALL THE NICE ASCII ART THAT'S POINTING STRAIGHT AT THE CODE IN QUESTION
AND THEN OF COURSE YOU KNOW RIGHT AWAY MAYBE THERE ARE SOME IMPORTANT REASONS NOT TO USE RUST
AND THEN OH I DON'T EVEN KNOW WHAT TO SAY AND I SAW THAT IN MY COMMENTS I WRITE SOMETHING ABOUT THE GOD BAT
AND THEN ON 16 AND 18 WE ARE GOING TO PUT OUR UPDATED VERSION OF THE FRAME POINTER INTO THE FRAME POINTER SPECIAL REGISTER
AND THEN ON 17 WE RESTORE THE STATUS REGISTER RESTORING THE VALUE OF THE INTERRUPT FLAG
AND THEN ON 31 AND 32 WE PUT THAT VALUE INTO OUR FRAME POINTER REGISTER
AND THEN ONCE YOU HAVE THE VIDEO YOU WANT TO SHOW IT TO A USER AND SO YOU WOULD USE SOME SORT OF VASTLY IMPROVE HARDWARE WHICH WOULD BE PROVIDED BY A PERIPHERAL
AND THEN ONLINE 28 WE ADD ONE TO THAT VALUE
AND THEN ONLINE 4 WE UNWRAP
AND THEN PERFORM THE EPILOGUE
AND THEN PROGRAM WILL
AND THEN PUSHING THOSE REFERENCES TO THIS VECTOR OUTSIDE OF OUR CLOSURE THAT'S GONNA GO AHEAD AND YELL AT US FOR SAYING HEY THESE REFERENCES DON'T LIVE LONG ENOUGH BECAUSE THEY GET DROPPED AT THE END OF THIS CLOSURE
AND THEN REALLY� DEPENDS ON THE PROJECT THAT YOU WANT TO WORK WITH
AND THEN RETURNING THE ERROR IF NEEDED
AND THEN SLOWLY MOVE TO MORE AMBITIOUS THINGS
AND THEN SLOWLY WORK YOURSELF UP WITH THE ECOSYSTEM LEARN THE DIFFERENT LIBRARIES
AND THEN SLOWLY WORKED OVER TO SMART POINTERS
AND THEN THE BOSS' BOSS COMES IN WITH ANOTHER CLIENT'S FILE FOLDER AND WE OPEN THAT UP AND PUT IT AT THE VERY TOP OF THE STACK
AND THEN THE FIRST THING INSIDE THE FUNCTION IS THAT WE MAY NEED TO SAVE THE OTHER WORKING REGISTERS
AND THEN THE INFINITE LOOP THAT IS GOING TO CONTROL THE ROBOT IT IS STILL CALLED OUTUR LOOP
AND THEN THE LAST PIECE OF KIND OF RELEVANT INFORMATION HERE IS I CO SHEPHERD THE RUST ERROR HANDLING WORKING GROUP
AND THEN THE THIRD RESOURCE I WOULD SUGGEST IS THE AVR
AND THEN THERE'S A MIDDLE GROUND THERE WHERE YOU HAVE THE LIB VELOCE THAT CAN GIVE YOU ACCESS TO COLLECTIONS LIKE VECTOR AND HASHMAPS AND SO FORTH
AND THEN THESE ARE THE MOMENTS THAT I STUMBLE ON THESE WAIT IF I WOULD DO THIS THIS WOULD NOT BE SECURE
AND THEN THIS PARTICULAR CLASS OF ERROR THEN IS HANDLED BY THIS FUNCTION
AND THEN TOWARDS THE END WE'LL POP REGISTERS 29 28 AND 25 OFF THE STACK
AND THEN WANTED MORE CONVENTIONAL EXPERIENCE I STARTED WORKING ON KIBRARIAN FOR MANAGING SCHEMATICS AND FOOTPRINTS FOR KICAD
AND THEN WE CAN CALL THIS DEBUG METHOD AND HAVE PRINTED OUT A REALLY NICE REPRESENTATION OF OUR DATA
AND THEN WE COLLAPSE ALL THE PINS INTO A SINGLE VARIABLE THAT WE ARE GOING TO USE HERE
AND THEN WE EXPECTED TO WRITE A LOT MORE FROM THE GROUND UP SO IT'S ESSENTIALLY LIKE WE HAD THIS BUILDING
AND THEN WE GET THE NUMBER OF TICKS IN THE TIMER REGISTER DIVIDED BY THE MAGIC NUMBER 58 AND MULL APPLY IT BY FOUR BECAUSE THE UNIT IS FOUR MILLISECONDS
AND THEN WE GO AHEAD AND WE SEND THAT UPDATED VERSION OF THE FRAME POINTER
AND THEN WE GO DO LINES 8 THROUGH 10 WHICH ARE THE BODY OF THE FUNCTION
AND THEN WE HAVE A FEW MORE CALLEE SAVED REGISTERS THAT WE'LL PUSH ON TO THE STACK
AND THEN WE HAVE THIS OPEN64 FUNCTION AT THE END
AND THEN WE JUMP OVER INTO THE FUNCTION
AND THEN WE POP REGISTER 1 AND REGISTER ZERO SUCH THAT AT THE END OF THIS INTERRUPT WE HAVE NOW RESTORED ALL OF OUR REGISTERS
AND THEN WE PUSH REGISTER 1 ON TO THE STACK
AND THEN WE PUSH REGISTER 24 ON TO THE STACK
AND THEN WE PUT OUR
AND THEN WE SEE THAT WE'RE GONNA SKIP THE CALLEE SAVE POP INSTRUCTIONS AND THEN INSERT OUR FRAME POINTER RESTORE CODE
AND THEN WE SEE THIS EARLY EXIT IF THERE'S NO NEED TO RESTORE THE FRAME POINTER
AND THEN WE SUBTRACT 1 FROM IT ONLINE 31
AND THEN WE WAIT 100 MILLISECONDS BETWEEN THE SOUND WAVES SO 100 MILLISECONDS IS CORRESPONDING TO 25 000 TICKS
AND THEN WE WILL TALK ABOUT HOW RUST IS NOT SUITABLE TO WRITE CODE THAT IS ACTUALLY THAT ACTUALLY PREVENTS THESE CHANNELS
AND THEN WE WILL USE THIS MASK
AND THEN WE'LL OUTPUT THAT VALUE INTO OUR FRAME POINTER
AND THEN WE'RE GOING TO HAVE A HEAP POTENTIALLY
AND THEN WE'RE GOING TO PERFORM THIS SEQUENCE
AND THEN WE'RE GOING TO TALK ABOUT MIRI WHICH IS A SUPER COOL TOOL I'M TALKING ABOUT
AND THEN WHAT IS IT SUPPOSED TO DO TO RESTORE THE FRAME POINTER IN THE EPILOGUE
AND THEN WHEN IT'S DONE WE RETURN BACK TO WHEREVER IT WAS THAT WE WERE INTERRUPTED
AND THEN WHEN WE FINISH THAT UP DO THAT WORK AND MY BOSS LEAVES AND THEN I CAN RESUME DOING WHAT I WAS DOING BEFORE I GOT INTERRUPTED
AND THEN WHEN WE FINISH THE BOSS' BOSS' CLIENT WE CLOSE THAT FILE AND TAKE IT AWAY
AND THEN YOU
AND THEN YOU CAN INSTALL MIRI JUST AS A COMPONENT SO IT'S THE SAME AS INSTALLING CLIPPY OR RUSTFMT OR WHATEVER
AND THEN YOU CAN MAYBE USE WELL START ON COMMANDLINE TOOLS
AND THEN YOU CAN RENDER IT MANY TIMES ON THE GPU FROM MANY ANGLES
AND THERE ARE A COUPLE OF WAYS THAT WE CAN ADD OPTIMISATION BARRIERS AND THE FIRST EXAMPLE IS THAT WE CAN ADD AN OPTIMISATION BARRIER WHICH ADDING AN EMPTY ASSEMBLY DIRECTIVE
AND THERE ARE A FEW IMPORTANT THINGS TO KNOW ABOUT WRITING SOFTWARE FOR AN EMBEDDED CONTEXT THAT MAKE IT SLIGHTLY DIFFERENT FROM THOSE OTHER ENVIRONMENTS
AND THERE ARE CERTAIN TYPES OF ERRORS THAT ARE CAUGHT WITHIN THE PARSING PHASE
AND THERE ARE LOTS OF THESE
AND THERE ARE MANY LIMITATIONS ACTUALLY
AND THERE ARE REALLY TWO MODELS THAT MIGHT BE USEFUL FOR THINKING ABOUT THE STACK
AND THERE ARE SEVERAL PROBLEMS TO SOLVE HERE AND NOT ALL OF THEM ARE TECHNICAL
AND THERE IS A GOOD REASON FOR THAT AND I WILL EXPLAIN WHY THAT IS BUT AS A CRYPTOGRAPHIC ENGINEER OR ASPIRING CRYPTOGRAPHIC ENGINEER I HAVE TO WRITE IT IN RUST INSTEAD
AND THERE IS A HIGHER FRONT COST HERE AND YOU WIN IT BACK AND IF YOU'RE REPLACING C PLUS PLUS YOU WIN IT BACK VERY QUICKLY
AND THERE IS A LOT OF CONTROVERSY AROUND THIS ONE
AND THERE ISN'T REALLY AN API THAT HAS FULL COVERAGE OF ALL THE OPERATING SYSTEMS YOU MIGHT WANT TO TARGET
AND THERE'S A WHOLE HOST OF NUANCE TO THIS
AND THERE'S ALSO THIS IDEA THAT IF IT WORKS DON'T TOUCH IT
AND THERE'S ANOTHER APPROACH CALLED STENCIL AND COVER
AND THERE'S ANOTHER RUST LIBRARY PIET GPU BY LEVINE
AND THERE'S BETTER WAYS OF ACHIEVING THE SAME RESULT
AND THERE'S NO ONE CORRECT CHOICE HERE
AND THESE ARE SORT OF THE BEDROCK SYSTEMS PROGRAMMING LANGUAGES THAT SUPPORT PYTHON
AND THESE BOOKEND THE BODY OF THE FUNCTION
AND THESE THINGS HAVE BECOME AVAILABLE AND IMPORTANT WHEN THEY APPLY TO THE PROBLEMS OF EDUCATION AND WRITING DOCUMENTATION BECAUSE THEY CAN HELP TO LOWER THE ENTRY BARRIERS FOR PEOPLE WHO ARE NEW TO PROGRAMMING AND TODAY I'M GOING TO SHOW YOU HOW WE CAN APPLY THESE IDEAS TO RUST AND SYSTEMS PROGRAMMING IN PARTICULAR
AND THEY ARE IMPRESSIVE PERFORMANCE WITH A HIGH END GPU
AND THEY ARE MOVING QUITE FAST
AND THEY COME IN THREE MAIN SECTIONS
AND THEY DON'T ACTUALLY CONSIDER THEMSELVES TO BE EXPERT SOFTWARE ENGINEERS
AND THEY DON'T REALLY HAVE ANY WORK AROUNDS
AND THEY HAVE VERY LIMITED TIME AND RESOURCES BECAUSE USUALLY THEY HAVE OTHER COMMITMENTS MAYBE THEY'RE PROFESSORS OR STUDENTS OR RESEARCHERS
AND THEY MIGHT NEED TO USE UNSAFE BECAUSE THEY NEED TO GO SUPER FAST WITH THIS THING
AND THEY PROVIDE THAT CALLING CONVENTION THAT I DESCRIBED EARLIER
AND THEY SHOULD BE
AND THEY SHOULD BE AVOIDING DOWNCASTING FOR SPECIFIC BEHAVIOR WHENEVER POSSIBLE
AND THEY WON'T FALL TOGETHER WHEN STACKED
AND THEY'RE ACTUALLY WRITTEN MOSTLY IN C PLUS PLUS AND SORT OF WRAPPED UP NICELY IN PYTHON FOR PEOPLE TO USE
AND THIS ART DOES REALLY COMPUTE
AND THIS BUG ONLY COMES UP ON THE AVR PLATFORM
AND THIS CAN BE A DIFFICULT� IT CAN BE DIFFICULT IN LANGUAGES WHERE YOU CAN POTENTIALLY BE OVERWHELMED IF YOU TRIED TOO MUCH AT ONCE
AND THIS EPILOGUE POPS 24
AND THIS GIVES YOU DOING MANY DIFFERENCES AND GIVES YOU THIS BROAD BASIS THAT YOU CAN PUT ALL THE THINGS THAT YOU NEED TO DO INTO CONTEXT
AND THIS HAS A SUPER COOL SIDE EFFECT WELL NOT SO SIDE EFFECT
AND THIS HAS THE SAME DOG AND SAME CAT METHODS WHICH ARE GONNA BE USED TO CHECK TO MAKE SURE THAT
AND THIS IDEA OF RUNNING THE PLAYGROUND CODE IN THE BROWSER CAN GO A LOT FURTHER BECAUSE WE HAVE LOTS OF TECHNIQUES FOR VISUALISING DATA
AND THIS IS A BIT LIKE A PROGRAM
AND THIS IS A BIT LIKE WHEN MY KIDS ARE IN THE OTHER ROOM AND I'M WORKING ON THE DISHES
AND THIS IS A FORUM THAT A BUNCH OF PEOPLE WHO LOVE PROGRAMMING FOR AVR ANSWER ALL KINDS OF QUESTIONS
AND THIS IS A MINIATURE VERSION OF SAVING AND STORING THE STATUS REGISTER
AND THIS IS A PROCESS THAT'S REFERRED TO AS CLOBBERING THE REGISTERS
AND THIS IS A SIMPLE YES OR NO ANSWER
AND THIS IS A WAY TO MAKE SURE THAT YOUR EXAMPLES COMPILE EVEN IF YOU CHANGE YOUR CODE
AND THIS IS ACTUALLY A CASE WHERE CORRECTNESS OF THE SOFTWARE IS VERY IMPORTANT
AND THIS IS ACTUALLY A PRETTY BIG DANGER FOR US
AND THIS IS AS I UNDERSTAND IT THIS IS WHY PATHFINDER HAS BOTH RENDERERS
AND THIS IS GREAT FOR PROTOTYPING
AND THIS IS SORT OF A BUG WHERE IT MAY NOT BE OBVIOUS RIGHT AWAY BUT HAVING IT CAUGHT AT COMPILE TIME IS A BIG DEAL
AND THIS IS SORT OF A THEME WITHIN RUST AND IT'S SOMETHING THAT THE TYPE SYSTEM REALLY HELPS WITH
AND THIS IS SORT OF AN AREA WHERE I DON'T REALLY WANT TO SPEND ANY TIME SORT OF WRANGLING EXTERNAL TOOLS OR YOU KNOW FIXING ISSUES WITH THEM
AND THIS IS SORT OF AN IDEA I THINK WE NEED TO COMBAT
AND THIS IS THE PARTS OF THE STANDARD LIBRARY THAT DON'T REQUIRE MEMORY ALLOCATIONS AND DON'T REQUIRE PLATFORM SUPPORT
AND THIS IS WHAT WE FOUND TO BE THE MOST HELPFUL FOR REVIVING A DEAD RUST PROJECT
AND THIS IS WHERE THE SYSTEM PART OF ECS COMES IN
AND THIS IS WHERE WE STORE THE STATE THAT WE'RE CURRENTLY WORKING ON AS I HAD MENTIONED PREVIOUSLY IN THE DESK METAPHOR
AND THIS IS WHERE YOU ARE
AND THIS IS YOU KNOW
AND THIS LAST ROLE WAS KIND OF
AND THIS LIKE A COUPLE OF THESE SO IN RUST BEEN MAKE THESE NEW TYPE STYLE REFERENCES AROUND INTEGERS A STRUCT THAT ONLY HAS SOME INTEGER TYPE AND IMPLEMENT SOME OPERATIONS ON THAT THAT ARE PRESUMABLY IN CONSTANT TIME
AND THIS MEANS I CAN ACTUALLY FOCUS MY TIME ON DEVELOPING A BETTER ALGORITHM OR ACTUALLY DOING SOME OTHER WORK AND NOT HAVING TO WORRY ABOUT BUGS AS MUCH AS I WOULD IN ANOTHER LANGUAGE
AND THIS REALLY REMOVES A LOT OF THE FRICTION AROUND TESTING
AND THIS TABLE ACTUALLY LOOKS A BIT MORE ROSY THAN THE REAL SITUATION
AND THIS WAS
AND THIS WAS THE FIRST THING I GOT REALLY EXCITED ABOUT
AND THIS WILL ALSO ENSURE THAT YOUR EXAMPLE CODE DOESN'T GO OUT OF DATE
AND THIS WILL HOLD YOU BACK
AND THROUGH THE LENS OF REPRESENTATIONS ART CAN INVITE TO US PERCEIVE THE SAME OBJECT IN DIFFERENT WAYS
AND TO HANDLE SOME INTERNAL REQUESTS
AND TO REPEAT MYSELF SMALL STEPS IN YOUR CODE ARE OKAY
AND TO TURN RIGHT YOU HAVE TO SET THE LEFT FORWARD WHEEL HIGH AND THE RIGHT FORWARD WHEEL LOW FOR AN AMOUNT OF TIME SO IF YOU MOVE THE LEFT WHEEL THE ROBOT IS GOING TO TURN TO THE RIGHT
AND TRY NOT TO CHANGE TOO MUCH
AND TURN RIGHT
AND USE IT WITH CAUTION
AND USUALLY IT'S NOT THIS SERIOUS
AND WANTS TO ENSURE THAT YOU KNOW YOU DON'T DANGLE ANY REFERENCES AND ALL THAT GOOD STUFF THAT THE BORROW CHECKER IS OF COURSE FAMOUS FOR
AND WE ALREADY SAID THAT INPUT IS A PROGRAM
AND WE ALSO CALL THAT CLEARING THE INTERRUPT FLAG
AND WE ALSO HAVE THE METHOD AVAILABLE THAT ACCEPTS THE DOG BY REFERENCE AND RETURNS A STRING
AND WE ARE DOING THE SAME
AND WE ARE RUNNING OUT OF TIME
AND WE CAN ALSO COMBINE THIS TECHNIQUE WITH THE OTHERS WE HAVE DISCUSSED SO FAR BECAUSE THIS TIME WE CAN HAVE ACCESS NOT ONLY TO THE STATIC CONTEXT INFORMATION THAT IS PROVIDED BY THE COMPILER BUT ALSO TO THE DYNAMIC STATE AT THE RUNTIME
AND WE CAN DISABLE INTERRUPTS WITH THE CLI COMMAND
AND WE CAN DISPLAY DATA LIKE LOCAL VARIABLES OR FUNCTION CALL RESULTS AND AS A USER STEPS THROUGH THE CODE IT BECOMES REALLY EASY TO SEE HOW THE STATE CHANGES WITH EACH FUNCTION CALL
AND WE CAN DO THE SAME THING FOR OUR MICROCONTROLLER FOR OUR LITTLE COMPUTER IF WE NEED TO DELAY AND PERFORM SOME COMPUTATION AT A LATER POINT IN TIME
AND WE CAN FIND THAT FUNCTION HERE CALLED REPORT MUTABILITY ERROR
AND WE CAN LOOK AT THE OUTPUT OF OUR COMPILER
AND WE CAN SORT OF THINK OF THE GENERAL PURPOSE REGISTERS AS A PILE OF ETCH A SKETCHES ON A TABLE
AND WE CAN THINK OF A COMPILER AS A BOX
AND WE CHECK
AND WE DIDN'T HAVE TO THINK ABOUT IT THE HARD WAY AND I LOVE THAT BECAUSE I'M LAZY
AND WE DIDN'T USE THE CORRECT SYNTAX
AND WE DON'T ALLOW DIVISION WHICH IS A NON CONSTANT TIME ALGORITHM AND WE DON'T ALLOW PRINTING OF SECRET VALUES
AND WE DON'T HAVE ACCESS TO OPERATING SYSTEM THINGS LIKE A FILE SYSTEM
AND WE EXPECTED A FLOATING POINT NUMBER F SIXTY FOUR BUT WE FOUND INTEGERS
AND WE FOUND THESE PROBLEMS MADE SOME OF THE EXISTING SYSTEMS OVERLY COMPLEX
AND WE HAVE AN OUT COMMAND THAT WILL TAKE A VALUE FROM A SPECIAL REGISTER
AND WE HAVE THESE VECTORS OF FLOATING POINT NUMBERS IN IT
AND WE HAVE TO BE CAREFUL TO TRY AND AVOID BUGS AS MUCH AS POSSIBLE
AND WE LOOK AT THAT ONE
AND WE NEED TO WRITE IT DOWN BECAUSE WE PROBABLY WERE USING THAT PREVIOUSLY
AND WE NOTE THAT THIS IS THE SEQUENCE TO ADJUST THE FRAME POINTER
AND WE NOTE THAT'S NOT THE PRIOR VALUE OF THE FRAME POINTER REGISTER
AND WE OPEN THAT UP AND SET IT DOWN ON TOP OF THE PILE OF PAPERS ON MY DESK
AND WE READ IN THE FRAME POINTER ON LINES 11 AND 12
AND WE SAY THAT EVERY TIME WE COMBINE A PUBLIC VALUE WITH A SECRET VALUE IT IS ALSO A SECRET
AND WE SEE HERE THAT WE ACTUALLY GET A PANIC WHICH IS SORT OF LIKE RUST'S WAY OF YOU KNOW WINDING DOWN THE SYSTEM AND STOPPING EVERYTHING AND EXITING
AND WE SEE LINES 22 AND 23 REALLY NEED TO BE AFTER THE FRAME POINTER RESTORATION
AND WE SEE THAT'S THE SAME AS THIS SPECIAL EPILOGUE RESTORING THE STATUS REGISTER AND REGISTER 1 AND ZERO
AND WE SEE TWO MORE BOXES
AND WE SEE WE RESTORE THE FRAME POINTER BY DOING THIS ARITHMETIC
AND WE START ON 29
AND WE WANT TO UTILISE THESE CHECKS AND THESE TOOLS AS MUCH AS POSSIBLE BECAUSE WRITING JUST PLAIN ASSEMBLY IS REALLY HARD AND SUPER ERROR PRONE AND THEN THERE'S THE OTHER THING THAT IF WE ONLY WRITE ASSEMBLY THEN YOU'VE WRITTEN AN ASSEMBLY FOR AN INTEL PROCESSOR
AND WE WILL DO RELATIONAL ALGEBRA ALSO
AND WE WILL GO AHEAD AND CONNECT IT TO AN LED
AND WE'LL BE EXPLAINING WHAT ECS IS LATER IN THIS TALK
AND WE'LL SEE THAT WE USE IT BY PASSING IT AS THE INPUT TO OUR COMPUTER BOX FROM PREVIOUS
AND WE'RE GONNA BE TALKING ABOUT THE CURRENT SCIENTIFIC COMPUTING ECOSYSTEM
AND WE'RE GONNA PUSH IT ON TO THE STACK
AND WE'RE GONNA STORE THAT ON REGISTERS 28 29
AND WELL IT'S NOT SOME KIND OF MAGIC BECAUSE WE ALREADY CAN MAKE IT HAPPEN
AND WELL LEARNING SHOULD BE EASIER
AND WHAT DOES THIS LOOK LIKE IN TERMS OF WHAT WE WERE TALKING ABOUT WITH THE STACK
AND WHAT HAPPENS IN THE MIDDLE ARE LIKE FOUR STAGES
AND WHAT KIND OF REQUEST IT ACTUALLY SENDS
AND WHAT THE SECRET INTEGER CRATE PROVIDES SIDE CHANNEL RESISTANCE ON THE LANGUAGE LEVEL SO ON THE LANGUAGE LEVEL YOU'RE SURE THAT YOUR CODE LOOKS LIKE SOMETHING THAT SHOULD BE SIDE CHANNEL RESISTANT BUT IT DOES NOT ACTUALLY PREVENT THESE COMPILER OPTIMISATIONS
AND WHAT THIS DOES IS GUARANTEES THAT AT SOME POINT THIS MASK VALUE WOULD HAVE EXISTED ON THE STACK
AND WHAT WOULD YOU SAY IS THE BEST POINT ON THE LEARNING CURVE TO START INTERACTING WITH EXISTING PROJECTS IN YOUR EXPERIENCE
AND WHEN B IS DONE IT RETURNS BACK TO WHERE AN A
AND WHEN WE WANT TO GET IT BACK WE POP IT
AND WHEN YOU SEE A SUDDEN JUMP THAT'S WHEN YOUR BRUSHES ARE ADDED AND THE ALGORITHM IS USING THEM TO BETTER APPROXIMATE THE TARGET
AND WHILE CLEANING UP THE PYTHON CODE I STARTED HAVING A LOT OF NEW IDEAS COMING FROM THE EXPERIENCE I ACCUMULATED
AND WHILE IT ALREADY KIND OF WORKS LIKE THAT WITH THE STANDARD LIBRARY DOCUMENTATION BECAUSE IF YOU GO FOR EXAMPLE TO THE PAGE THAT DOCUMENTS
AND WHILE YOU CAN DO THIS MANUALLY BY USING FEATURE FLAGS FOR EXAMPLE OR YOU CAN USE ONE OF THE MANY RUST LIBRARIES FOR AUTOMATIC MOCKING BUT THE MAIN IDEA REMAINS THAT YOU WANT TO PROVIDE THE SAME INTERFACE BOTH IN YOUR REAL CODE AND IN THE MOCKED VERSION
AND WHY WE USED RUST AS A FOUNDATION IN OUR ENVIRONMENT
AND WITH PYTHON IT'S ALWAYS
AND WITH SUPPORT ALSO VERY FAST SERVERS
AND WITH THAT I WOULD LIKE TO GIVE A FEW CLOSING WORDS ABOUT USING RUST IN METAL FABRICATION
AND WITHOUT ANY EXTERNAL TOOLS WE CAN WRITE A UNIT TEST AND CHECK IT RIGHT AWAY
AND WRITING SOFTWARE MIGHT JUST BE PART OF SOMEONE'S JOB
AND YEAH
AND YES BASICALLY THAT'S LIKE THE HARD CONTENT OF MY TALK AND I WANT TO SPEND THE LAST FEW MINUTES TALKING ABOUT CONTRIBUTING TO MIRI
AND YES MIRI CANNOT INTERPRET YOUR FOREIGN FUNCTION BUT IT CAN INTERCEPT THIS CALL SO WHEN YOU'RE RUNNING YOUR PROGRAM
AND YOU
AND YOU CAN JUST READ THE CODE TAKE THE CODE CHANGE THE CODE AND DO SOME MORE EXPERIMENTS
AND YOU CAN PUT SOME LED INTO IT AND PROGRAM THAT THING WITH FOR LOOPS
AND YOU CAN SEE THE AVR LINE RANGES HERE
AND YOU CAN SEE WE HAVE THE SAME LITTLE STATUS REGISTER AND INTERRUPT CLEARING
AND YOU CAN THEORETICALLY COMPILE THAT FOR A CONTEXT
AND YOU CAN THINK OF THIS ARCHITECTURE AS RUN LENGTH ENCODING THE IMAGE
AND YOU CAN UPLOAD IT YOURSELF TO THE GPU
AND YOU HAVE SOMEONE SITTING AT A DESK MOVING PAPERWORK AROUND
AND YOU JUST MAKE A LIBRARY THAT CAN SERVE AS A COMPONENT ALONGSIDE THE OTHER COMPONENTS OF AN APPLICATION
AND YOU KNOW REALLY SAT DOWN AND DELIBERATELY THOUGHT ABOUT HOW CAN WE MAKE ERROR MESSAGES IN ELM YOU KNOW REALLY GOOD REALLY HELPFUL
AND YOU KNOW THE TWO LANGUAGES ARE VERY DIFFERENT HAVE DIFFERENT GOALS
AND YOU KNOW THERE ARE ENTIRE BOOKS WRITTEN ON HANDLING FLOATING POINT NUMBERS CORRECTLY
AND YOU KNOW THERE'S A LOT OF FACTORS GOING ON HERE
AND YOU KNOW THIS IS DEFINITELY A VALID CONCERN
AND YOU NEED TO HIT THAT SIXTY FRAMES PER SECOND DEADLINE IF YOU WANT TO HAVE A SMOOTH APP
AND YOU SEE THAT WE HAVE THE INSTANCE OF KEYWORD BEING USED
AND YOU'LL HAVE TO HAVE SOME BASIC UNDERSTANDINGS OF THE MODEL FOR EXAMPLE FOR THE SYNTAX IN ORDER TO ACCOMPLISH EVEN THE FIRST STEPS WITH THE LANGUAGE
ANDREW
ANDREW DONA COUCH WILL NOW GO
ANIMALS SIMPLY CANNOT WEIGH NEGATIVE WEIGHT
ANOTHER IMPORTANT STATUS REGISTER WE'LL TALK ABOUT LATER TODAY IS A FRAME POINTER
ANOTHER ISSUE OF COURSE IS THAT YOU ALREADY HAVE A LARGE CODEBASE WRITTEN IN ANOTHER LANGUAGE
ANOTHER LAYER ON ANOTHER ENCODE STEP
ANOTHER LIMITATION IS THAT MIRI IS SLOW SO IF YOUR TEST OR PROGRAM IS PERFORMANCE SENSITIVE IT CONSOLIDATE CAN TAKE A WHILE TO RUN YOUR PROGRAM EVEN IF YOU CAN DO IT
ANOTHER PAPER NAMED HOW TO ARCHITECTURE A QUERY COMPILER REVISITED WHICH IS PAPER ONLY BUT INSPIRES TENSORBASE IO
ANOTHER POINT MIGHT BE THAT THERE'S AN IMPORTANT LIBRARY THAT YOU DEPEND ON THAT'S ACTUALLY MISSING ON THE RUST SIDE OF THINGS
ANOTHER PROBLEM THAT I DIDN'T MENTION WAS THE ANIMATION LIBRARY
ANOTHER PROJECTION FROM THE WORK USES DEDICATED WELD IR FOR DATA
ANOTHER QUESTION FROM THE AUDIENCE
ANOTHER SUGGESTION QUESTION WAS WHY NOT TEACH STUDENTS HOW MEMORY ACTUALLY WORKS FROM THE START
ANOTHER TALK
ANOTHER THING THAT CAN MAKE THE BUG DISAPPEAR IS ADDING A MAP ERROR TO UNIT BEFORE I UNWRAP
ANOTHER THING YOU MIGHT PICK UP ON IS A LOT OF THE TIME A MOVE IS ADJACENT OR NEAR THE PREVIOUS MOVE
ANOTHER WAY I'M MOVING EDGES IS TO DRIVE THE BRUSHSTROKE'S ORIENTATION
ANY FRONT END ON GDB YOU LIKE TO USE
ANY FUTURE PLANS FOR MORE ROBOTS
ANY GIVEN POINT IS NOT LIKELY TO BE RANDOMLY SELECTED FROM ALL POSSIBLE POINTS WITH AN EVEN PROBABILITY
ANY OTHER QUESTIONS
ANY PAINTING IF YOU LOOK CLOSE ENOUGH IS JUST AN AMORPHOUS JUMBLE OF BRUSHSTROKES BUT THEY MAGICALLY COME TOGETHER AND MAKE YOU BELIEVE WHAT THEY PRESENT IS REAL
ANY PARTICULAR WEBSITE OR PLACE
ANY QUESTIONS
ANYONE WHO WANTED TO LEARN ABOUT THE GAME OR CONTRIBUTING GO TO THE MDBOOK
ANYTHING CAN HAPPEN WHEN YOU DELIVER UNDEFINED BEHAVIOUR
ANYTHING YOU WOULD CHANGE ABOUT RUST'S DIAGNOSTIC INTERFACE
ANYWAY THAT'S HOW OCHRE WORKS AND THAT'S WHY I MADE IT THE WAY I MADE IT
ANYWAY THERE ARE SOME QUESTIONS
ARCHITECT A HIGH PERFORMANCE SQL QUERY ENGINE IN RUST
ARDUINO DOES NOT HAVE ENOUGH POWER TO MOVE THE MOTORS SO WE CONNECT IT TO THE DRIVER
ARDUINO IS IDEAL TO BEGIN TO KIND OF PROJECT
ARE THERE A LOT OF THINGS I NEED TO LEARN PACKAGE MANAGER BUILD SYSTEMS ET CETERA
ARM IS ANOTHER EMBEDDED PLATFORM
ART IS NOT ALONE IN ITS PURSUITS TO CONSTRUCT THINGS INTO REPRESENTATIONS
ART IS NOT JUST ABOUT RECREATION OF REALITY EVEN IF YOU DO CHOOSE TO MAKE IT YOUR FOCUS IT'S AN INVITATION TO CO EXPERIENCE SOMETHING FROM YOUR PERSPECTIVE SOMETHING THAT USED TO BE BODILESS BUT YOU INVENTED A REPRESENTATION FOR IT AND FROM THAT PERSPECTIVE I GENUINELY THINK ANYONE CAN BE AN ARTIST
ART SCIENCE AND PROGRAMMING ARE SIMILAR IN THAT REGARD
AS A MONAD
AS A PROCEDURAL ARTIST AT EMBARK I SPEND MOST OF MY TIME MEDITATING ON WORKFLOW IN GAMES FROM PLAYER AND DEVELOPER PERSPECTIVES
AS A VERY CONSCIOUS CHOICE ON THE PART OF THE EARLY RUST CORE DEVELOPERS
AS AN INDUSTRY AND A MANUFACTURER WE NEED TO MAKE SURE OUR ENTERPRISE SYSTEM WOULD BE ABLE TO HANDLE THIS NEW WAY OF SPECIFYING COLOR SO RUST ENUM ALLOWED US TO DO THIS
AS ARTISTS WE MIGHT EMPHASISE THE WAY THE WOOL CURLS ARE REPETITION OF A PATTERN THAT TREES MAKE WHEN THEY SWAY ABANDONING OR WE MIGHT ADOPT A DIFFERENT PERSPECTIVE
AS BRUSHSTROKES BECOME SMALLER I USE A SAMPLING MASK TO GUIDE THE BRUSH PLACEMENT TOWARDS PLACES OF HIGHER FREQUENCIES
AS DESCRIBED BY MESSAGE PACK THEY ARE LIKE JSON BUT FAST AND SMALL
AS FAR AS COMPILER DIAGNOSTICS AGAIN I FEEL LIKE THOSE ARE MOSTLY AT A PRETTY GOOD PLACE
AS FOR THE WISHES THAT WE HAD IT WOULD BE GREAT IT WOULD HAVE BEEN GREAT IF WE COULD FIND MORE PRODUCTION USE CASES BECAUSE PRODUCTION READY CAN BE A VERY SUBJECTIVE TERM BUT THE REAL WORLD USING A REAL WORLD PRODUCT AS AN EXAMPLE REALLY ADDS CONCRETENESS TO IT
AS HE BREAKS APART
AS HUMANS WE ARE SENSITIVE TO SHARP TRANSITIONS BETWEEN DARKER AND LIGHTER ELEMENTS AND A SMALL DEVIATION CAN MAKE SOMETHING LOOK WRONG
AS I'M SURE EVERYONE WILL AGREE IT'S VERY ROUGH AT THE BEGINNING FOR EVERYONE
AS MICAH WAS MORE COMFORTABLE WE WERE ABLE TO USE THE IDEAL STATE DOCUMENT TO HAVE IN DEPTH DISCUSSIONS ABOUT WHAT THE IDEAL STATE OF THE GAME SHOULD LOOK LIKE
AS OF RIGHT NOW IN FUNDIES�2 STUDENTS DON'T HAVE TO DEPEND ON EXTERNAL LIBRARIES FOR ANYTHING EXCEPT FOR THE ANIMATIONS AND FOR UNIT TESTING
AS STEFAN SAID THIS IS LIKE A WAY OF SAYING IF THERE IS SOMETHING THAT IS NOT SPECIFIED IN A CLEAR WAY
AS SUCH SERIALIZATION SHOULD BE AT THE FRONT OF YOUR MIND WHEN ENGINEERING AND YET DESPITE THIS HOW TO REPRESENT DATA AS BYTES IS NOT A HOT TOPIC IN PROGRAMMING CIRCLES
AS SUGGESTED BY THAT PREVIOUS SLIDE OUR BACK END FOR THE RUST COMPILER IS LLVM
AS THAT CULTURE KIND OF LIKE MAKES ITS WAY INTO OTHER LANGUAGE ECOSYSTEMS AS WELL HOPEFULLY EVENTUALLY WE'LL GET TO A POINT WHERE WE HAVE SOMETHING THAT LOOKS MORE LIKE THIS
AS THE PLAYER DESTROYS ENEMIES THEY CAN COLLECT CURRENCY ALLOWING THEM TO DESTROY ENEMIES MORE EFFICIENTLY AND COLLECT MORE CURRENCY AND ITEMS AND SO ON
AS USUAL
AS WE CAN IMAGINE THESE ARE EXPENSIVE HIGH PRECISION MACHINES AND USING THIS MANUFACTURING EQUIPMENT IS VERY VERY IMPORTANT TO THE SUCCESS OF ANY MANUFACTURING OPERATION SO THE METAL FABRICATION INDUSTRY BENEFITS QUITE A BIT FROM THE USE OF SOFTWARE TO RUN THE BUSINESS
AS WE SAW AS I MENTIONED THE SPANS THE PARENT SPANS
AS WE SAW PREVIOUSLY THERE ARE USE CASES OF MULTIPLE PACKAGES
AS YOU CAN SEE A LOT OF METAL AND LOTS OF SPARKS
AS YOU CAN SEE I GET AROUND THE RECURRENCE OF DATA DEFINITION BY USING A SHARED POINTER
AS YOU CAN SEE IT'S NOT DONE IT CAN'T BE CLOSED
AS YOU CAN SEE THE PRINTER LINT FUNCTION IS EXPANDED
AS YOU CAN SEE THIS IS A VERY SIMPLE DYNAMIC DISPATCH EXAMPLE
AS YOU CAN SEE WE USE A MATCH EXPRESSION
AS YOU KNOW FOR BIGGER PRODUCTS LEVERAGES ARE JUST ABLE TO BE MORE DYNAMIC AND PERFORM ANALYSIS ONLY ON THE CODE AND IT IS PRETTY FAST THAT WAY
AS YOU LEARN THE COMPILER TO TRUST
AS YOU SAW THE LOGS ARE PRETTY SIMPLE AND PRETTY HARD TO COMPREHEND BECAUSE THERE IS NO CONTEXTUAL INFORMATION
AS YOU USE THE GPU BETTER YOU CAN SCALE UP BETTER WITH BIGGER GPUS
ASIDE FROM THAT ALL BYTES ARE INDEPENDENT
ASYNC AWAIT IS JUST ANOTHER FEATURE WHICH JUST A LITTLE TWEAK
AT EACH LEVEL OF ABSTRACTION OF THE COMPUTER SYSTEM YOU WILL FIND COMPONENTS DRIVEN BY DATA SENT OVER WIRES IN SERIALIZATION FORMIT
AT FIRST I WASN'T SURE IF I WOULD BE ABLE TO HELP OUT MEANINGFULLY SINCE I WAS LEARNING RUST AND AMETHYST
AT LEAST IN THE ENGLISH LANGUAGE WORDS ARE CONSTRUCTED FROM SYLLABLES SO IT IS POSSIBLE TO FIND REPETITION IN A TEXT EVEN IN THE ABSENCE OF REPEATED WORD
AT THE END OF THE DAY INSIDE THE RUST COMPILER THERE'S FUNCTIONALITY THAT SPECIFICALLY LOOKS FOR THIS CASE AND DETERMINES THAT IF THIS IS THE CASE SPITS OUT THIS ERROR MESSAGE AND DETERMINES THAT IS THE MOST RELEVANT ERROR MESSAGE TO FIX THE CODE THAT YOU'RE TRYING TO RUN
AT THE END OF THE DAY MAKING THESE DISCUSSIONS PUBLIC ON GITHUB WILL HELP CREATE AN ENVIRONMENT THAT ENCOURAGES OPEN DISCUSSION AND QUESTIONS WITH OTHERS
AT THE END OF THE DAY RUSTC ONLY WANTS THE RELEVANT ERRORS
AT THE MOMENT BEEN THE ALGORITHM IS RUNNING ON CPU
AT THE MOMENT ZEROING MEMORY IS OUT OF SCOPE BUT WHEN WE HAVE THIS INFORMATION ABOUT PUBLIC AND SECRET VALUES THEN WE'VE LAID THE GROUNDWORK TO SUPPORT THAT AS WELL
AT THE TIME I WAS JUST LEARNING PYTHON SO THIS WAS WRITTEN IN PYTHON
AT THE TOP OF THIS TYPE HERE THIS SPAN DIAGNOSTIC IS WHAT IS KIND OF RESPONSIBLE FOR HOLDING ON TO ALL OF THE DIFFERENT ERROR MESSAGES OR DIAGNOSTICS I SHOULD SAY THAT CROP UP DURING THE PARSING SESSION SPECIFICALLY
AT THE TOP WE HAVE THE ROOT ELEMENT TOURNAMENT WHICH IS A TYPE STRUCT
AT THE TOP WE'RE DIVIDING TWO INTEGERS AND GETTING A FLOATING NUMBER OUT
AT THIS LEVEL OF ABSTRACTION OF THE SYSTEM WE USUALLY THINK OF THE DATA IN TERMS OF SERIALIZATION
ATTACHING NAMES SUCH ADDS SPACESHIP OR ENEMY MAKE IT EASIER TO DESCRIBE THE PURPOSE TO SOMEONE ELSE
AUTOMATIC RUST PARSER GENERATION
AUTOMATICALLY GENERATING PARSERS MINIMISES THE CHANCE OF SOME OF THESE ERRORS OCCURRING FOR EXAMPLE THE NUMBER OF BITS BEING READ WILL ALWAYS MATCH THE SPECIFICATION
AVR IS A SERIES OF EIGHT BIT MICROCONTROLLERS
AVR IS ACTUALLY A VERY LIMITED PLATFORM
BARRING A FEW EXCEPTIONS EACH TWO BYTE SEQUENCE IN THE FILE IS UNIQUE
BASED ON THE EXPERIENCE YOU'VE HAD WITH PREVIOUS LANGUAGES WHAT WAS THE MOST DIFFICULT THING TO GRASP
BASICALLY
BASICALLY I BREAK IT DOWN INTO EDGE TILES AND SPANS
BASICALLY IN ONE OF THE TWO CASES IT'S SKIPPED ITS INSTRUCTION AND THE IMPORTANT THING TO SEE HERE IS THAT DEPENDING ON THIS VALUE
BASICALLY IT DOESN'T HANDLE HUMONGOUS SOLID SPACES VERY WELL
BASICALLY MY EXPERIENCE FROM ROSTER IS A POSITIVE
BASICALLY RUST CANNOT WORK CORRECTLY
BASICALLY THE STEP UPTAKING THE WINDOWS YOU HAVE HOME AND PAINTING THEM ON TO ONE FRAME ON YOUR MONITOR WHICH IS AN OPERATION CALLED COMPOSITING
BATMAN CAME BACK
BE CURIOUS ABOUT WHAT THE COMPILER TELLS YOU NOT JUST LIKE ALL RIGHT
BE HUMBLE
BECAUSE A LOT OF SCIENTIFIC CODE YOU NEED A LOT OF EXAMPLES
BECAUSE A LOT OF TIMES YOU REALLY DO KNOW WHAT YOU'RE DOING
BECAUSE AGAIN I THINK EVEN THOUGH THIS WAS A REALLY COOL KIND OF SPELUNKING TOUR FOR THE MOST PART I DON'T WORRY TOO MUCH ABOUT THE STATE OF ERROR HANDLING IN RUSTC ITSELF
BECAUSE AGAIN IT JUST LOWERS THAT OVERHEAD THAT MENTAL OVERHEAD OF WHEN YOU ENCOUNTER AN ERROR MESSAGE
BECAUSE AND THE
BECAUSE AT THE END OF THE DAY EVEN THOUGH ALL THE STUFF WE JUST SAW GOING THROUGH THE CODE EXAMPLES IT IS
BECAUSE BOTH COMPILERS WERE BUILT WITH DIFFERENT GUARANTEES IN MIND
BECAUSE ESPECIALLY IF YOU GO INTO THE LATER FEATURES YOU CAN JUST SAY OKAY
BECAUSE EVEN THOUGH I THINK IT WOULD BE INTERESTING TO KIND OF LIKE FOLD CLIPPY INTO RUSTC AT THE SAME TIME I DO ALSO KNOW THERE'S THIS VERY DELIBERATE
BECAUSE EVERYTHING ELSE WILL BE EASIER AND IT WILL BE EASIER TO GET ALONG
BECAUSE HERE THE DESK IS NOT THE REGISTERS
BECAUSE HONESTLY I LIKE DESKTOP APPLICATIONS
BECAUSE I KNOW ELM ALSO
BECAUSE I'M TRYING TO ELIMINATE ANYTHING NON ESSENTIAL
BECAUSE IF YOU HAVE HUNDREDS OF THOUSANDS OF ROWS IN YOUR CSV WE GET A TEN TO TWENTY TIMES SPEED UP GOING FROM PROLOG TO RUST USING THE SAME ALGORITHM BECAUSE THERE'S SOME KIND OF CONSTANT TIME THAT YOU CAN IMAGINE EXPANDING OUT
BECAUSE IF YOUR PROGRAM TAKES FOREVER TO RUN IT USUALLY MEANS THAT YOU'RE GOING TO HAVE A LOT MORE TROUBLE SORT OF ITERATING OR MAYBE RUNNING A DIFFERENT KIND OF ANALYSIS
BECAUSE IN REAL LIFE THINGS ARE ALWAYS SLIGHTLY MORE COMPLEX
BECAUSE IT ALLOWS ME TO FOCUS ON SOME BASICS AND AT LEAST KNOW WHAT I DON'T KNOW ABOUT MY CODE
BECAUSE IT CAN FEED A NUMBER TOO BIG THAT'S NOT UNDEFINED BEHAVIOUR IN RUST BUT THAT'S UNDEFINED BEHAVIOUR IN C
BECAUSE IT REDUCES THE
BECAUSE IT SEEMS LIKE IT'S GOING TO BE CREATING A LOT MORE PROBLEMS THAN IT WOULD SOLVE
BECAUSE IT THE EMPOWER PHILOSOPHY OF THE RUST COMMUNITY HAS OF BEING RELIABILITY SOFTWARE AND AT THE SAME TIME HAVING A SUPER HELPFUL COMMUNITY WITH TOOLS THAT HELPS YOU TO BUILD THAT
BECAUSE IT TURNS OUT EVERY TIME SOMETHING COULD GO WRONG AS IN SOME KIND OF DIAGNOSTIC COULD BE ADDRESSING SOME ERROR IN THE COMPILATION PROCESS RUSTC WILL GO AHEAD AND DO IT
BECAUSE IT WILL ACTUALLY KEEP THIS MASK VALUE COMPLETELY INTACT AND IT WILL NOT BE ABLE TO OPTIMISE THROUGH THAT VARIABLE
BECAUSE IT'S
BECAUSE OF SOME OF THE COMPILATION QUIRKS IN RUST THAT'S NOT ALWAYS A GOOD IDEA AND WHAT NEEDS TO BE DONE TO MAKE RUST PROGRAMMING LANGUAGE WE CAN USE FOR CRYPTOGRAPHIC CODE
BECAUSE OF THESE WIRES AND THE PHYSICAL SEPARATION OF THE SYSTEM'S COMPONENTS THE DATA WHICH DRIVES EACH COMPONENT MUST BE AND WELL SPECIFIED AGREED UPON FORMATS
BECAUSE OF THIS IT SLOWED TO A HALT UNTIL 2020 WHEN I WATCHED MICAH'S RUST CONF TALK ABOUT EXPERIENCES WITH AMETHYST
BECAUSE OF THIS IT'S IMPORTANT THAT COMPONENT STORAGES ARE RESPONSIBLE FOR CONTAINING AND MANAGING COMPONENTS OF ONE TYPE
BECAUSE ONE OF THE NICE THINGS ABOUT RUST IS YOU DON'T HAVE TO WORRY TOO MUCH ABOUT SHOOTING YOURSELF IN THE FOOT OR TO MAKE WELL MISTAKES THAT YOU WOULDN'T KNOW ABOUT IT
BECAUSE OUR BROKEN VERSION OF THE INTERRUPT SERVICE ROUTINE CLOBBERS THREE ADDITIONAL REGISTERS
BECAUSE PERSONALLY I CONSIDER TIME SPENT WRITING BUILD SYSTEM CODE TO BE A NECESSARY EVIL AND I WANT TO MINIMIZE AS MUCH OF THAT AS POSSIBLE
BECAUSE PROLOG WAS VERY LOGICAL ESPECIALLY THE SCHEMA CHECKING PARTS OF IT IT WAS EXTREMELY FAST FOR US TO WRITE IT IN PROLOG BUT HOWEVER IT HAD POOR PERFORMANCE SO OBVIOUSLY IT IS NOT THE BEST FOR BIT TWIDDLING
BECAUSE STUDENTS DON'T HAVE TO WORRY ABOUT ADDING EXTRA DEPENDENCIES OR ADDING EXTRA LIBRARIES IN ORDER TO GET THEIR CODE WORKING
BECAUSE TESTING IS THE NATURAL TENDENCY OF SERIALIZATION WE NEED FORMATS THAT ALLOW US TO NEST DATA EFFICIENTLY
BECAUSE THE NON COMPUTE RENDERING IS TRYING TO ACHIEVE MORE PORTABILITY
BECAUSE THE TIME LIMIT HAVE NO CURRENT COMPILATION SYSTEM
BECAUSE THIS IS RUSTFEST I WILL TALK A LITTLE BIT MORE ABOUT RUST
BECAUSE UNWINDING THE STACK IN THE CASE IS VERY EXPENSIVE IN TERMS OF MEMORY USE AND PROCESSER
BECAUSE WE HAD SOME TECHNICAL DIFFICULTIES
BECAUSE WHEN YOU LEARN CONCEPTS WITH A LANGUAGE LIKE RUST YOU WILL HAVE TO FACE MANY NEW THINGS JUST WHEN YOU START
BECAUSE YOU ARE TAKING A DEPENDENCE ON LAZY STATIC IF IT WASN'T FOR THE FEATURE ALLOC THEY ARE NOT TAKING THAT
BECAUSE YOU CAN REALLY DO TWO THINGS AT ONCE
BECAUSE YOU CAN RIGHT AWAY GO TO THE UNSAFE BLOCK AND THE REVIEWING IS SHRUNK BECAUSE YOU LOOK AT THE UNSAFE BLOCKS AND SEE IF THEY'RE OKAY
BECAUSE YOU KNOW I JUST WANT TO SEE WHAT'S HAPPENING AND I WANT TO SORT OF STEP THROUGH MY CODE
BECAUSE YOU KNOW THAT MEANS A LOT OF PEOPLE CAN DO THEIR JOBS A LOT QUICKER
BEFORE EVEN TALKING ABOUT UNDEFINED BEHAVIOUR I THINK IT'S SUPER IMPORTANT TO KNOW OR TO DISCUSS WHY PEOPLE USE UNSAFE RUST IN THE FIRST PLACE
BEFORE I TALKED ABOUT ITEMS IN SPACE SHOOTER
BEFORE WE CAN START BUILDING PARSERS AND PARSER COMBINATORS
BEFORE WE GET STARTED I HAVE A SHORT DISCLAIMER
BEFORE WE TALK ABOUT THE FORMAT WE NEED TO TALK TALK ABOUT THE NATURE OF DATASETS AND USE THE GAME OF GO
BEFORE WE WERE WRITING EACH COORDINATE IN A SINGLE BYTE SO WITH THIS ENCODING ALL MOVES WILL ALSO SAVE SOME AMOUNT OF SPACE
BEFORE WE WRAP UP A QUICK THOUGHT OUT TO THOMAS AND MAIK FOR DEALING WITH MY RUST PROGRAMMING ON AT THAT DAILY BASIS
BEFORE YOU CAN RUN THIS EXAMPLE YOU NEED TO MAKE SURE THAT A MINI REDIS IS RUNNING ON YOUR MACHINE
BEFORE YOU CAN START EXPERIMENTING WITH ASYNCHRONOUS CODE YOU NEED TO FOLLOW A NUMBER OF STEPS BECAUSE THEY HAVE PREREQUISITES
BEING HUMBLE LIKE THIS GETS YOU A LONG WAY
BENCHMARK TIME
BETWEEN JAVASCRIPT AND RUST WHICH DO YOU THINK WOULD HAVE BETTER PERFORMANCE
BEYOND THAT IT'S JUST A GOOD TOOLKIT FOR IF YOU HAVE ANYTHING THAT'S LAYOUT DEPENDENT BASED ON THE SIZE OF WHY WINDOW OR IF YOU'RE DOING SOMETHING THAT'S A WAVE FORM VISUALIZER OR OR A LINE GRAPH IN A DATA VISUALIZATION PROGRAM
BIT STRINGS ARE LEAF NODES SO WE MOVE TO THE NEXT CHILD OF THE RAW TCP HEADER NODE DESTINATION PORT
BIT STRINGS ARRAYS STRUCTS ARRAYS CONTEXTS AND FUNCTIONS
BORING CODE IS OKAY
BOTH DIANE AND ME ARE HERE IN THE AT A CONFERENCE AND IN THE CHAT SO FEEL FREE TO ASK ANY QUESTIONS AT THE END OF THE TALK OR PUT THEM IN THE CHAT DURING THE TALK AND WE WILL TAKE CARE OF THEM
BOTH OF THEM GIVE AN EXAMPLE LIKE OBJECT ARRANGEMENT IN KITTIWAKE OR PIXEL IMAGE SYNTHESIS WE SEARCH FOR A NEW CONFIGURATION THAT LOOKS PERCEPTUALLY SIMILAR TO THE EXAMPLE WHILE NOT BEING A COPY
BOTH OF THOSE CRATES THEY ARE ONLY A BEST EFFORT THEY'RE ONLY BEST EFFORT AND THEY DON'T GUARANTEE ALL OF THE THEY DON'T FIX ALL OF THE COMPILER OPTIMISATION ISSUES
BOTH PLACES
BOTH THE MAC AND THE WINDOWS HAVE BEEN USING THAT SINCE MAC SINCE 2004 AND WINDOWS SINCE 2007 WITH VISTA
BOTH TRICKS KIND OF WORK IN 90% OF THE CASES
BOTH WORKS AIM TO CAPTURE THE SHEEP BUT THE OUTCOMES OR REPRESENTATIONS DIFFER DRASTICALLY
BREAK MY EXAMPLE
BRUSHSTROKES FOLLOW ALONG THE EDGES AND DON'T CROSS THEM BECAUSE THAT WOULD VIOLATE THE PERCEPTUAL CONTOUR BORDER
BUFFER PUSH VERTEX
BUILD YOUR OWN RUST Y ROBOT
BUT AGAIN I THINK THAT THE YOU KNOW I'M GETTING INTO THE WEEDS FOR SOMETHING NOT RELATED TO THIS TALK
BUT AGAIN IN AN ELM CONTEXT
BUT AGAIN THIS IS A GOOD HABIT THAT STUDENTS MUST BE ABLE TO DEVELOP ANYWAYS
BUT ALL THE WORK
BUT ALSO A VARIETY OF OTHER PLATFORMS AND YOU CAN DEFINITELY RUN IT ON A LOT OF SYSTEMS
BUT ALSO GET HIGHER QUALITY SO YOU CAN RENDER TEXT WITH IT
BUT ALSO INVESTIGATORS DID FIND THAT DATA RACES OR CONCURRENCY BUGS IN THE THERAC 25 CONTROL SOFTWARE CONTRIBUTED TO THE ACCIDENTS
BUT ALSO RUST'S PLACE IN THIS ECOSYSTEM AND WHERE IT CAN HELP RESEARCHERS WRITE GOOD CODE
BUT ALSO USE IT AS DOCUMENTATION IS SORT OF
BUT ANOTHER THING THAT RUST DOES REALLY WELL IS ACTUALLY IT'S QUITE A GOOD PROTOTYPING LANGUAGE OR DEBUGGING LANGUAGE
BUT ANYONE INTERESTED IN PREVIEWING IT CAN CHECK IT OUT AMETHYST GITHUB IO SPACE SHOOTER
BUT ANYWAYS
BUT ANYWAYS A SHAMELESS PLUG
BUT ARE THERE ANY SITUATIONS WHERE YOU WOULD NOT USE IT
BUT AS SOMEONE NOT FAMILIAR WITH THE CODE IT WAS HARD TO KNOW WHERE TO BEGIN WITH REFACTORING THE CODEBASE
BUT AS YOU CAN SEE WE NEED TO REFACTOR ANYWAY
BUT AT THE END OF THE DAY I DON'T THINK IT IS MORE COMPLEX OR MORE CRAZY OR MORE INGENIOUS THAN ANYTHING ELSE INSIDE OF RUSTC AT THE END OF DAY
BUT AT THE SAME TIME EXPLAINING MY CURRENT INTENTIONS FOR THE GAME
BUT AT THE SAME TIME IT'S ALSO I WOULD SAY REALLY USEFUL FOR EVEN SEASONED DEVELOPERS WORKING IN YOUR LANGUAGE RIGHT
BUT AT THE SAME TIME IT'S SOMETHING THAT WE NEED SOMETHING SUPER SPECIAL THAT RUST NEEDS TO WORK AND BE ABLE TO DO THE AWESOME STUFF THAT IT ALREADY DOES
BUT BECAUSE I HAVEN'T TRIED IT YET
BUT BECAUSE I'M WRITING THIS EXAMPLE FOR A BUTTON HANDLING LIBRARY I'LL ADD A BUTTON
BUT BEFORE WE TALK ABOUT THE SYSTEM PART OF ECS
BUT BEYOND THAT IT'S A RESOLUTION INDEPENDENT FORMAT
BUT CARGO ALSO INTRODUCES A PACKAGE LAYOUT THAT WILL FOLLOW
BUT DOING THAT INSIDE OF A CLOSURE WE GO AHEAD AND CREATE THOSE REFERENCES
BUT ENCAPSULATION IS SOMETHING THAT STUDENTS HAVEN'T ENCOUNTERED BEFORE
BUT EVEN IF YOU DISAGREE MAYBE JUST THINK ABOUT IT
BUT FIRST WE NEED A LITTLE BIT MORE INFORMATION HOW TO READ THIS AVR ASSEMBLER
BUT FOR EXAMPLE IF WE GO BACK TO THE PERFECT CASE WHERE WE DIDN'T HAVE ANY UNDEFINED BEHAVIOUR WE CAN JUST DO CARGO MIRI RUN AND MIRI WON'T COMPLAIN AND RETURN THE SAME AS YOUR REGULAR PROGRAM
BUT FOR ME WHAT BROUGHT ME FIRST WAS STARTING WITH THE RUST BOOK
BUT FOR PEOPLE REVIEWING YOUR CODE IT'S VERY HELPFUL
BUT FOR THE MOST PART I THINK SAFE DEFAULTS ARE A GOOD CHOICE
BUT FOR THE ONES THAT IT DOES GIVE YOU YOU CAN GO AHEAD AND TAKE THAT AND BASICALLY LOOK THAT UP INSIDE OF THE ERROR INDEX TO GET SOME MORE CONTEXT SOME MORE INFORMATION ON THIS TYPE OF ERROR THAT YOU'RE SEEING
BUT GIVE YOURSELF TIME AND FOCUS ON THIS FIRST STEP
BUT GOUACHE WILL RETURN EVENTUALLY
BUT HAVING IT CAUGHT AND SORT OF ADDRESSED RIGHT AWAY IS A BIG DEAL
BUT HAVING TO HAVE FOR EXAMPLE LIKE I SHOWED THE RECURSIVE DATA DEFINITIONS
BUT HERE WE WIL BE TALKING AS MIRI IS JUST THE STANDALONE TOOL OUTSIDE THE COMPILER THAT CAN INTERPRET YOUR PROGRAMS
BUT HONESTLY I'VE DONE VERY LITTLE RUST DEVELOPMENT AT THIS POINT
BUT I DO SEE THE USER EXPERIENCE BENEFIT OF HAVING IT
BUT I DON'T THINK
BUT I DON'T THINK I'M
BUT I GUESS IT'S THE DIFFERENCE IN TWO SCHOOLS
BUT I HAD TO SLOWLY WORK MYSELF UP
BUT I HAVE BEEN USING RUST FOR ABOUT A YEAR AND A HALF
BUT I HAVE ONE QUESTION
BUT I HAVEN'T HAD THE OPPORTUNITY TO DO THAT
BUT I HOPE TO SOON
BUT I NOW BECAUSE I READ THIS CHAPTER IN THE BOOK AND I CAN SYNC
BUT I REALIZED THAT THE CONCERNS THAT I WAS HAVING CARLO KNEW THE CODE AND COULD GUIDE ME THROUGH THE PROBLEMS THE PROJECT WAS HAVING
BUT I THINK IT'S EASIER TO GET UP AND RUNNING GOOD CODE IN RUST THAN IN OTHER LANGUAGES
BUT I THINK IT'S NOT YOU KNOW
BUT I THINK WHAT I REALLY LIKE TO EXPRESS DON'T BE DISCOURAGED
BUT I THOUGHT YOU TWO THINGS YOU MENTIONED WERE FAIRLY CLEAR BUT THANK YOU FOR CLEARING THAT UP TOO
BUT I WAS SEARCHING FOR SOMETHING THAT STRUCK THAT TRADEOFF BETTER FOR UIS
BUT I WILL SAY THAT THE RUST TEAM HAS DONE A VERY GOOD JOB OF SUPPORTING THE RUST COMPILER ON A LOT OF PLATFORMS
BUT I WOULD SAY YOU KNOW MAYBE IF THERE'S A
BUT I'M NOT GOING TO TALK ABOUT THEM SPECIFICALLY HERE
BUT I'M NOT SURE I'M SURE EVERYONE OR ALMOST EVERYONE HAS INTERACTED WITH THE STANDARD LIBRARY TO DO STANDARD OPERATION READING FILES WHATEVER AND THAT MEANS SOMEHOW YOU'RE USING FOREIGN FUNCTIONS
BUT I'VE NEVER USED THESE MYSELF
BUT I'VE REMOVED ALL OF THE CORE LIBRARY CODE AND THE CRATES THAT ARE IN USE
BUT IF HUMBLE YOU ARE
BUT IF THIS WERE SYMMETRIC IF THIS MIRRORED COLLECTIVELY IT SHOULD BE PUSH IN OUT POP
BUT IF WE DON'T FIND A BLANK ONE WE PICK UP ONE THAT'S IN USE
BUT IF WE WANTED TO TALK ABOUT MONADIC IMPLEMENTATIONS OF RUST THIS IS WHAT WE'LL HAVE TO INTRODUCE
BUT IF YOU HAVE CLIPPY AND RUN CARGO CLIPPY IT WILL TELL YOU THAT THE VARIABLE THAT THE DEPENDS ON IS NOT THERE
BUT IF YOU'RE REPLACING PROLOG THE SORT OF AMORTIZED COSTS ARE MORE IMPORTANT SO YOU HAVE TO WORRY ABOUT WHERE YOU REPLACE IT AND YOU HAVE TO BE MORE CAREFUL ABOUT THAT
BUT IF YOU'RE SUPER INTERESTED IN CONTRIBUTING TO MIRI WRITING THIS IS A SUPER EASY WAY TO START
BUT IN AN EMBEDDED CONTEXT YOU COMPILE IT ON A HOST MACHINE LIKE YOUR DESKTOP COMPUTER AND THEN YOU SEND THAT TO THE EMBEDDED DEVICE AND RUN IT ON THE EMBEDDED DEVICE
BUT IN FACT I'M USING UNSAFE FOR THIS CODE BECAUSE I'M USING STATIC MUTABLE VARIABLES
BUT IN PRACTICE YOU RUN INTO SLIGHT THINGS THAT HOLD YOU BACK
BUT IN THAT WORST CASE IT MIGHT RUN BUT NOT AS YOU INTENDED TO SO THAT PROGRAM MIGHT DO ANYTHING
BUT INSTEAD OF ONE PIECE OF CODE CALLING ANOTHER FUNCTION IT'S A BIT LIKE THE WORLD IS WHAT'S CALLING YOUR FUNCTION
BUT INTERESTINGLY IT WON'T CHECK FOR IF YOU HAVE AN EXTRA TRAILING ANGLE BRACKET
BUT IT ALSO HAS COMPETITIVE PERFORMANCE TO LANGUAGES LIKE C AND C PLUS PLUS
BUT IT ALSO SPENDS A LOT OF TIME MAKING SURE THAT THE LANGUAGE IS SORT OF SUITABLE FOR NON EXPERT PROGRAMMERS WHICH IS OFTEN THE CASE FOR SCIENTIFIC RESEARCHERS
BUT IT HAS PERFORMANCE TRADEOFFS MORE APPROPRIATE TO THE GAME THAN A UI BECAUSE THE REASON FOR THAT IS THE END TO END RENDER TIME FROM LOADING A FONT OR GENERATING A SCENE FROM SCRATCH TO PROCESSING IT UPLOADING IT AND RENDERING IT ON THE GPU IS NOT EVEN REALLY FASTER THAN MAYBE FULL ON CPU RASTERIZATION SOMETIMES
BUT IT HAS SOME DOWNSIDES
BUT IT IS
BUT IT IS A GOOD APPROACH FOR OTHER SITUATIONS SUCH AS GAMES
BUT IT IS A PROBLEM BECAUSE YOU KNOW I'VE DEFINITELY SEEN PEOPLE LEAVE PROJECT BECAUSE THEY DON'T FEEL THEY'RE UP TO THE TASK
BUT IT IS THE CASE THAT SOFTWARE DOES AFFECT REAL PEOPLE
BUT IT LEADS TO THINGS BEING A LITTLE TRICKIER
BUT IT MAKES IT HARDER TO WORK ON OLDER HARDWARE AND MAKES IT HARDER TO PORT BETWEEN DIFFERENT APIS
BUT IT WASN'T LIKE AN EXORBITANT TIME INVESTMENT
BUT IT WOULD BE GREAT
BUT IT'S ALSO A SYSTEMS LANGUAGE EXPLICITLY DESIGNED FOR NON EXPERTS AND IT'S DESIGNED TO LOWER BARRIERS
BUT IT'S ALSO AN AREA WHERE PERFORMANCE�PROGRAMS IS VERY IMPORTANT
BUT IT'S ENOUGH TO SHOW IT'S POSSIBLE
BUT IT'S NOT JUST C PLUS PLUS
BUT IT'S NOT THE CODE THAT I'VE WRITTEN BEFORE OR THAT I HAVE WRITTEN MY EXERCISES IN
BUT IT'S OFFICIALLY DEPRECATED ON APPLE PLATFORMS
BUT IT'S SORT OF HOW THEY'RE ALL BAKED INTO THE LANGUAGE AND THEY'RE ON BY DEFAULT WHICH IS REALLY IMPORTANT
BUT JUST TO KIND OF REITERATE A LITTLE BIT ABOUT ME
BUT KEEP IN MIND EVERY ONE IS A SMALL PIECE OF DATA WITH A FUNCTIONALITY FOR AN ENTITY IT'S EASIER TO HAVE A HOLISTIC VIEW OF THE ENTITY'S BEHAVIOR
BUT LET ME SHOW YOU AN EXAMPLE OF HOW TO USE THESE RAW POINTERS AND HOW TO USE UNSAFE AND SO ON
BUT LET'S LOOK AT AGAIN BACK AT OUR COMPUTER MODEL AND SEE WHAT
BUT LET'S SORT OF GET A VAGUE IDEA OF WHAT IT IS INSIDE THIS MEMORY
BUT LIKE I SAID THE UNSAFE BLOCK IS SORT OF VERY HELPFUL HERE
BUT LLVM MIGHT BE NEW
BUT MAYBE IT IS A LITTLE AWKWARD WITH MEMORY SHARING NEEDED
BUT MIRI TRIES TO BE DETERMINISTIC AS MUCH AS IT CAN BUT WHEN YOU DISABLE IT IN ISOLATION
BUT MY POINT HERE IS THAT UNSAFE IS EVERYWHERE NOT BECAUSE PEOPLE ARE NOT GOOD DOING THEIR JOB BUT BECAUSE WE NEED IT WE ACTUALLY NEED IT
BUT NONE IN BASIC COURSES
BUT NOT ON AVR
BUT NOTE THAT SEQUENCE IS INTERRUPTED BY THIS OTHER SEQUENCE
BUT NOW I WANT TO SHOW YOU I WANT TO BECAUSE IT'S A LITTLE BIT HOW MIRI WORKS ACTUALLY
BUT OF COURSE DURING THE BORROW CHECKING PHASE AS WELL IT ALSO CHECKS FOR LIFETIMES
BUT OFTEN TIMES IT'S WRITTEN BY A VERY SMALL TEAM
BUT OH I PROBABLY NEED TO WRITE A TEST TO MAKE SURE THAT IT WORKS
BUT ONCE YOU FIND THEM THEY
BUT ONE OF THE MOST IMPORTANT THINGS THAT WE HAVE DONE IS IN ENTERPRISE SOFTWARE THE DES MOINES THE DOMAIN IS COMPLEX AND WE ARE ACHIEVING A HIGHER LEVEL OF EFFICIENCY SEPARATING THIS OUT
BUT ONE REASON I LIKE WRITING RUST IS I CAN ALMOST ALWAYS IGNORE UNSAFE CODE AND NOT HAVE TO THINK ABOUT IT
BUT OTHER MORE CAPABLE PLATFORMS I THINK USING
BUT OTHERWISE WE'RE GOING TO PRINT GOT SOMETHING ELSE
BUT REMEMBER THE FIRST SIGNIFICANT DIFFERENCE FOR DEVELOPING AN EMBEDDED IS THAT WE HAVE THESE VERY TIGHT RESOURCE CONSTRAINTS
BUT RIGHT AWAY IT'S A LOT NOISIER
BUT RIGHT NOW A LOT OF PERFORMANCE ORIENTED DEVELOPERS ARE SAYING OKAY
BUT RIGHT NOW I'LL GIVE YOU JUST A BRIEF SENSE OF WHAT THEY
BUT RUST HERE REALLY HELPS ME BECAUSE ENTIRE CLASSES OF BUGS ARE ELIMINATED COMPARED TO ANOTHER SORT OF UNSAFE SYSTEMS PROGRAMMING LANGUAGE
BUT RUST'S FOUNDATIONAL VALUES HELP US TO WRITE GOOD SOFTWARE
BUT SOMETHING IN THE WORLD
BUT STILL THERE'S A 95% CHANCE THAT THE
BUT STILL WE CAN TRY OUR BEST IN MAKING THIS AS EASY AS POSSIBLE TO HAVE ADD THESE SORT OF INTERACTIVE ELEMENTS TO ANY PROJECT BECAUSE WE HAVE TOOLS LIKE RUST DOC WHICH CAN GENERATE DOCUMENTATION FROM THE SOURCE CODE
BUT TECHNICALLY THE LINKING IS STILL POSSIBLE EVEN THOUGH THERE IS NO STANDARD WAY OF DOING IT
BUT THANK YOU VERY MUCH FOR LISTENING AND FOR YOUR PATIENCE WITH MY TECHNICAL DIFFICULTIES AT THE BEGINNING
BUT THAT GUIDE IS QUITE COMPLETE
BUT THAT IS SUPER EXPERIMENTAL
BUT THAT MEANS IT'S NOT MY BUG
BUT THAT WE HAVE TWO OUTPUTS
BUT THAT'S MOSTLY BECAUSE SWIFT AND TYPESCRIPT BOTH HAVE REALLY NICE INTEGRATIONS WITH IDES
BUT THE COST OF THESE OPERATIONS
BUT THE IMPORTANT THING HERE IS THAT THE CONDITIONAL VALUE IS SECRET
BUT THE IMPORTANT THING TO NOTE HERE IS THAT SOME ARE DONE IN 1 AND SOME ARE DONE IN 3
BUT THE LLVM LIBRARY SERVES AS THE BACK END FOR MANY OTHER LANGUAGES INCLUDING JULIA AND SWIFT AND MANY OTHERS
BUT THE MAIN PROBLEM REMAINS NOT ALL RUST CODE COMPILES DOWN YET
BUT THE NORM WITH ERROR MESSAGES FOR DEVELOPERS FOR PROGRAMMERS IS THERE SOMETHING WE HAVE TO DECIPHER RIGHT
BUT THE SECOND REASON IS A LITTLE LESS CONTROVERSIAL IN THE SENSE THAT MANY PROJECTS WE HAVE IN RUST
BUT THE THING THAT CROPPED UP IN MY MIND THE WORD THAT I WOULD KIND OF ATTRIBUTE ALL OF THIS TO IS EAGERNESS
BUT THE WORLD SAYS OH WAIT
BUT THEN I CONNECTED THOSE LOGICAL PINS TO D7 D5 D6 AND D4 AND THAT I HAVE THEM LONG VARIABLE NAMES TO REFER TO EACH WHEEL
BUT THEN IN OUR EPILOGUE WELL FIRST ON 22 AND 23 WE POP OUR VALUES FROM REGISTERS 28 AND 29
BUT THEN WE WILL GO MORE IN DEPTH AND LOOK AT THE RSC ON SECRET TYPES TO SEE HOW WE COULD MAKE RUST FOR SUITABLE FOR SUCH CODE
BUT THERE ARE OTHER DEBUGGING AND OBSERVABILITY LIMITATIONS
BUT THERE ARE SOME BIG DOWNSIDES
BUT THERE ARE TWO
BUT THERE ARE WAYS TO ACCESS PYTHON AND C PLUS PLUS CODE IN RUST AS WELL
BUT THERE IS A PROBLEM IF WE GO BEYOND THE STANDARD LIBRARIES
BUT THERE IS EVEN LIKE IN THE ACID FUTURE WHERE THIS PRODUCT IS WELL DEVELOPED TEN YEARS FROM NOW AND VERY SOLID
BUT THERE'S KIND OF THIS CENTRAL TRADEOFF HERE
BUT THERE'S SOME REALLY INTERESTING IDEAS THERE
BUT THEY CAN ALSO REPRESENT THE STATE OF PINS ON OUR CHIPS
BUT THEY HAVE THE MASTERING RUST THE SECOND ONE IS QUITE GOOD
BUT THEY WILL STILL HAVE TO USE THE ANIMATION LIBRARY TO RUN THEIR CODE
BUT THINKING ABOUT IT IN THIS PARTICULAR CORNER CASE WHEN I WOULD DO THIS IN GO MY
BUT THIS ALSO BRINGS SOME PROBLEMS BECAUSE PYTHON IS ACTUALLY USUALLY QUITE SLOW OF A LANGUAGE
BUT THIS ALSO CATCHES REAL BUGS
BUT THIS CRATE HAS ITS OWN PROBLEM
BUT THIS IS ALSO YOU KNOW YOU CAN DO THAT WITH WHATEVER SMALL BOARD YOU WANT AND THEN A SMALL SENSOR AND THEN IT REACTS TO THE SOUND BUT ALSO TO SHOCK
BUT THIS IS THE BUTTON HANDLING LIBRARY THAT I'M WRITING AN EXAMPLE FOR
BUT THIS WILL ACTUALLY BE PUBLISHED AS PART OF OUR DOCUMENTATION
BUT ULTIMATELY YOU KNOW I THINK IT WOULD BE SUPER GREAT AS THIS CULTURE OF JUST TRYING TO BE MORE HELPFUL TO DEVELOPERS TRYING TO BE MORE HELPFUL TO NEW LEARNERS OF A PROGRAMMING LANGUAGE
BUT UNFORTUNATELY BECAUSE OF RUST'S STILL MANUAL MEMORY MANAGEMENT THAT'S GOT TO BE SOMETHING THAT HAS TO BE WORKED AROUND
BUT UNFORTUNATELY RIGHT NOW THIS IS A VERY DIFFICULT TRANSITION STEP
BUT UNFORTUNATELY THEY HIDE A LOT OF IMPLEMENTATION DETAILS
BUT USING A SLIGHTLY DIFFERENT METAPHOR
BUT USING THE GPU COMES WITH A CATCH
BUT WE ALSO YOU KNOW WHEN YOU'RE WRITING CODE AND PROTOTYPING YOU REALLY WANT TO PRINT OUT THE VALUE OF YOUR ADA OFTEN AND SORT OF SEE WHAT'S GOING ON TO IT YOU KNOW WHAT'S HAPPENING DURING EXECUTION
BUT WE ARE AT A RUST CONFERENCE SO LET'S FOCUS ON RUST
BUT WE CAN CONTINUE WITH THE Q AN A IN THE CHAT
BUT WE CAN GIVE A USER THIS TO GO THROUGH THE EXAMPLE LINE BY LINE WHILE ALSO SHOWING WHAT EACH FUNCTION WILL DO
BUT WE CAN SEE DOWN HERE THIS ERRORS BUFFER WHERE IT'S BASICALLY HOLDING ON TO ALL OF THE DIAGNOSTICS THAT ARE CREATED DURING THIS PARTICULAR PHASE
BUT WE CAN SEE WHAT THE BROKEN CODE'S DIFFERENCE IS
BUT WE CAN TAKE THIS IDEA A LITTLE BIT FURTHER AND MAKE THIS CODE EXAMPLE EDITABLE SO I CAN CHANGE THE VALUE OF THE KEY AND RUN THIS CODE AGAIN AND I CAN SEE THAT THE STATE HAS ALSO CHANGED
BUT WE FORGOT TO OF COURSE DENOTE THE STRING IS SUPPOSED TO BE MUTABLE
BUT WE HAVE THIS LABEL
BUT WE HAVE THREE BROADLY SPEAKING
BUT WE NOTE THAT WE BREAK SYMMETRY HERE
BUT WE STILL DO HAVE A LOT OF THE BASIC FUNCTIONALITY
BUT WE STILL HAVE A LONG WAY AHEAD OF US BECAUSE THE WEBASSEMBLY ECOSYSTEM HAS NOT MATURED YET
BUT WE WANTED TO AVOID REPEATING THIS DATA AND INSTEAD EXTRACTING THEM INTO THEIR OWN GENERIC MOTION COMPONENT ATTACHED TO ANY OTHER ENTITY THAT REQUIRES MOTION
BUT WHAT IS AN INTERRUPT
BUT WHAT WAS MORE INTERESTING IN MY OPINION IS THE WAY THIS PROJECT'S OBJECTIVE THAT IS TO REPRESENT A TARGET IMAGE IN A BUDGETS OF 50 POLYGON SLIDES OR HUNDREDS LIKE THE EIFFEL TOWER
BUT WHEELS IS STILL THE OWNER OF THOSE WHEELS
BUT WHEN
BUT WHEN AN ERROR MESSAGE POPPED UP I WAS JUST SO INTIMIDATED THAT I WOULDN'T EVEN READ IT RIGHT
BUT WHEN I'M DEVELOPING FOR EMBEDDED I OFTEN START WORKING ON A PROJECT WITH THE
BUT WHY IS RESERVING SPACE BREAK MY CODE
BUT YEAH
BUT YEAH IT IS A TIME INVESTMENT
BUT YEAH JOIN THE AMETHYST DISCORD�TO LEARN MORE ABOUT THAT
BUT YOU CAN ALSO RELATE IT TO OTHER CONCEPTS THAT YOU EVER RELATED BEFORE
BUT YOU SEE WE HAVE MORE TO LEARN IF IT'S ONLY THE MUTE BUTTON
BUT YOU STILL HAVE THE POSSIBILITY OF IF YOU DON'T HAVE THE LINTER THEN YOU MAY NOT BE CHECKING TO MAKE SURE THAT ERROR IS NIL
BY MAKING IT DRESS
BY REPRESENTING THIS IN AN ARRAY OF FIXED SIZED ELEMENTS WE CAN PROCESS DATA INDEPENDENTLY AND THEREFORE PARALLELIZED
BY THE WAY THIS IS JUST MY OPINION
BY USING PHANTOM DATA TYPES HERE WE CAN CREATE EMUMS FOR A JAPANESE YIN OR U S
BYE BYE
C COMPILATION OR INTERPRETATION CAN POSSIBLY BE DONE IN MICROSECONDS
C HAS A LOT OF RULES FOR UNDEFINED BEHAVIOUR AND THOSE RULES ARE NOT THE SAME
CAN WE RUN THAT
CAN YOU COMMENT ON THAT OR KNOW ANYTHING ABOUT THAT
CAN YOU ELABORATE A LITTLE BIT ON THAT
CAN YOU HEAR ME NOW
CANNY GIVES A CRISPER RESULT BUT COMES AT A FOUR TIMES SLOWER GENERATION COST
CARGO ALLOWS YOU TO MANAGE DEPENDENCIES AND HAVE REPEATABLE BUILDS
CARGO IS A FULL FLEDGED TOOL
CARGO IS LIKE AN UMBRELLA TO DO MOST OF THE OPERATIONS LIKE TESTING DOCS
CARGO IS MORE THAN A DEPENDENCY MANAGEMENT
CARGO TOOL IS ALSO VERY EXTENSIBLE IN ITSELF
CARLO SUPINA AND MICAH STRIVE
CAUSING THAT IS ALSO UNDEFINED BEHAVIOUR AND THERE ARE LOTS OF RULES THAT NEED TO BE TAKEN INTO ACCOUNT HERE
CERTAINLY
CIAO
CODE THAT WILL VALIDATE
COLLISIONS ARE DETECTED IN A SYSTEM SPACESHIP ITEM COLLISION SYSTEM
COLTON DONELLY TAKES RUST TO SCHOOL
COLTON DONNELLY AND THIS IS RUST FOR FRESHMEN
COMING FROM C PLUS PLUS THIS WAY OF EXPRESSING TYPED UNIONS IN RUST HAS BEEN INCREDIBLY POWERFUL BUT AS WITH ALL THINGS IN THE REAL WORLD THINGS WERE NOT AS EASY AS THEY SEEM
COMING UP WITH AN ALGORITHM TO PREDICT THE VALUE OF A DOT MAY NOT BE APPARENT BY LOOKING AT SCATTER PLOT
COMPARED WITH THE POPULAR CENTRALIZED SCHEDULE
COMPILATION THERE IS NOT MUCH TO TALK ABOUT
COMPUTATION AND EFFECTS ON THE WORLD
COMPUTATIONAL DRAWING IS MY HOBBY PROJECT WHICH IS DESIGNED TO IMITATE TRADITIONAL DRAWING FROM REFERENCE BY SEARCHING FOR A DEACON INSTRUCTION OF THE TARGET INTO DISCRETE BRUSHSTROKES INVITING THE EXPERIENCE TO BECOME OF THE WORK TO ITS ROUGH STAGES TO FINAL DETAILS
COMPUTATIONAL DRAWING IS STILL VERY MUCH WORK IN PROGRESS AND I HOPE TO OPEN SOURCE IT ONCE IT'S DONE
CONSIDERING A SCREEN IN JSON
CONSIDERING RUST FOR SCIENTIFIC SOFTWARE
CONSIDERING THAT THE FIRST THING TREE BUF HAS TO DO IS REORGANIZE YOUR DATA INTO A TREE OF BUFFERS BEFORE STARTING AND REVERSE THAT INFORMATION WHEN READING THE DATA IT HAS NO RIGHT TO MATCH THE SPEED OF MESSAGE PACK MUCH LESS SIGNIFICANTLY OUT PERFORM IT
CONSUMABLES ARE DROPPED BY ENEMIES WHEN DESTROYED
CONTRAST THAT TO SENDING THE DATA TO THE GPU IN SAY JSON
CONTRIBUTORS TO RUST HAVE KIND OF THOUGHT OF BEFORE FOR HOW TO GO AHEAD AND IMPROVE ERROR HANDLING OR ERROR HANDLING IN RUSTC SPECIFICALLY
COOL
COOL BUT IT GETS MORE CONCEPTUALLY INTERESTING AS WE ADD MORE BRUSHES
COOL COOL
CPU GPU AND IT IS HUMAN DEBUGABLE AND FAST ENOUGH COMPILATION FOR OLAP
CREATE A WAY TO EXPRESS PHYSICAL COLOR SAMPLE
CURRENT STATE AND IDEAL STATE
CURRENT STATE DOCUMENT DESCRIBED THE GAME AS IT WAS AND THE IDEAL STATE DESCRIBED THE GAME AS I THOUGHT IT SHOULD BE AFTER REFACTOR
CURRENTLY I WORK ON THE FIREFOX WEB BROWSER ON THE UI
CURRENTLY RUST HAS AN IMMATURE GUI ECOSYSTEM
CURRENTLY THE INSTRUCTORS USE JAVA EXCEPTIONS TO TEACH STUDENTS HOW TO PROPERLY HANDLE ERRORS
CURRENTLY THREE ENEMY TYPES
DAAN
DAAN AND DIANE GET US TO THE HYPE
DATA DRIVEN COMPETENTS CONNECTED BY WIRES
DECIDING WHAT QUALITIES TO LOOK FOR IN A CANDIDATE WHEN YOUR TECHNOLOGY STACK USES RUST IS INCREDIBLY CHALLENGING BECAUSE IT IS SUCH A BLEEDING EDGE TECHNOLOGY AND SO NEW THAT COMPARED TO OTHER LANGUAGES THAT HAVE BEEN AROUND FOR A LOT LONGER IT CAN BE HARD TO FIGURE OUT WHAT TO WRITE IN A JOB DESCRIPTION
DEFINITELY
DEFINITELY FOLLOW THERE AND FALL IN LINE WITH DATA ORIENTED PROGRAMMING
DEPENDING ON THE VALUE OF THE CONDITIONAL THE RUNTIME OF THE ALGORITHM CHANGES AND SO HERE WE HAVE A CASE WHERE THE COMPILER INTRODUCED A SIDE CHANNEL WHICH WOULD BE A SIDE CHANNEL
DETERMINING IF I HAD TIME AND IF I HAD A PLAN AND WHAT NEEDED TO BE WORKED ON
DIAGNOSTICS WITH A CAPITAL D
DIFFERENT DEPENDENCY OR WITHOUT THAT DEPENDENCY AND IN A MORE HARD FORMAT FOR YOU
DIFFERENT THINGS THAT YOU HAVE TO KEEP IN MIND
DIRECTLY IT'S OFTEN HARD TO FIND THE RIGHT PDFS
DISALLOWING CREATION
DO CONSIDER SERIALIZATION AND REPRESENTATION AS FIRST CLASS CITIZENS NEXT TO ALGORITHMS AND CODE STRUCTURE
DO I HAVE TO LEARN A LOT OF LIBRARIES A LOT OF LANGUAGE CONTENTS A LOT OF SYNTAX
DO SOME MEMORY COPIES DO SOME CLONES
DO SOME RELATIVELY SIMPLE THINGS
DO YOU FEEL THAT THE DESIGN DECISIONS OF RUST WITH RESPECT TO ERROR LOCALITY HELPS THE MESSAGES COMPARED TO FOR EXAMPLE ANOTHER LANGUAGE LIKE TYPESCRIPT
DO YOU FEEL THERE IS A DIFFERENCE BETWEEN STARTING A GAME
DO YOU HAVE ANY IDEA WHAT HINDERS PRODUCTIVITY IN RUST BESIDE THE BORROW CHECKER
DO YOU KNOW OF A GOOD REFERENCE FOR AVR ASSEMBLY
DO YOU MIND IF I GO INTO A COUPLE OF QUESTIONS THAT WERE ON THE CHAT
DO YOU MIND RESTARTING QUICKLY
DO YOU THINK IN A VERY DISTANT FUTURE IT WILL BE POSSIBLE TO HAVE MIRI INCLUDED IN A BINARY TO HAVE RUST AS A SCRIPTING LANGUAGE INSIDE YOUR RUST PROGRAM
DO YOU THINK THAT MAKING TYPES OF A STANDARD LIBRARY LESS DEPENDENT ON THE GLOBAL ALLOCATOR WOULD MAKE YOUR JOB EASIER IN ANY WAY
DO YOU THINK THAT WILL AFFECT YOU IN ANY WAY LIKE IN DEVELOPING NEW TYPES
DO YOU THINK WOULD MOST IMPROVE TEACHABILITY
DO YOU WANT TO PRECISE SOMETHING OR SAY THIS IS SOMETHING THAT CAME TO MIND JUST NOW
DOCUMENTATION IS AWESOME
DOCUMENTATION IS IMPORTANT FOR SOLIDIFYING KNOWLEDGE ABOUT PROJECT ARCHITECTURE DECISIONS
DOESN'T EXACTLY TELL YOU STRAIGHT UP WHAT THE PROBLEM IS RIGHT
DOING SOMETHING TO IMPROVE IT
DOLLAR SO WHEN WE CREATE A STATEMENT LIKE THIS WHERE WE TRY TO ADD THE JAPANESE YIN TO THE U S
DOLLAR WE WOULD GET A FRIENDLY COMPILE ERROR THAT TELLS US EXACTLY WHAT HAPPENED
DON'T ASK ME TO
DON'T GET FRUSTRATED
DON'T GET OVERWHELMED
DON'T WORRY ABOUT IT
DON'T WORRY ABOUT KNOWING WHAT IT IS RIGHT NOW
DOWNGRADED MEANS THEY CAN BE PUT IN A MUTABLE ARRAY THAT WE CAN SEND TO OTHER MODULES TO MODIFY THEM
E YES SO THIS IS NOT
EACH BOX HOLDS A SINGLE BIT
EACH COMPONENT IS DATA DRIVEN AND TRANSFERS INFORMATION ON WIRES IN PURPOSE BUILT
EACH ENTITY AND THE RESPONSE LOOKS SOMETHING LIKE THIS
EACH LANGUAGE HAS DIFFERENT DEGREES OF DIFFICULTIES
EACH MODEL CONSISTS OF FUNCTIONS THAT IT EXPORTS AND THAT WOULD BE OUR RUST FUNCTIONS AND IT ALSO HAS FUNCTIONS THAT ARE DECLARED AS IMPORTED AND THESE IMPORTED FUNCTIONS ARE PROVIDED BY THE CALLER AND USUALLY THEY'RE USED FOR CALLING JAVASCRIPT FUNCTIONS FROM THE RUST CODE AND THIS IS WHAT MAKES IT POSSIBLE FOR RUST PROGRAMS TO INTERACT FOR EXAMPLE WITH DOM AND BROWSER FUNCTIONS
EACH MODEL HAS ITS OWN SEPARATE MEMORY AND THIS MEMORY IS NOT SHARED BETWEEN THE MODULES AND THIS MEANS THAT IF AN IMPORTED RUST FUNCTION TRIES TO ACCESS ITS STATE WHEN IT IS EXECUTED IT WILL FAIL BECAUSE ITS MEMORY READING DOES NOT CONTAIN THE EXPECTED DATA
EACH OF THESE ENUM VARIANTS ARE DESCRIBED IN THEIR OWN SMALL ASCII DIAGRAMS IN ANOTHER SECTION OF THE SAME DOCUMENT
EACH OF THOSE STAGES IS A COMPLETELY SEPARATE SEARCHES SO WHEN A FIRST STAGE IS DONE THE SECOND STAGE HAS TO JUST DRAW ON TOP OF WHAT HAS BEEN DRAWN BEFORE
EACH TOOL CHAIN IS LIKE A PACKAGE AND YOU HAVE MULTIPLE VARIANTS
EACH TYPE IS ANNOTATED WITH THE THREE SLASHES
EARLIER WE TALKED ABOUT THE MONADIC BEHAVIOR OF RUST
EARLY RESULTS COMPARED TO THE CLICKHOUSE AND BASED ON THE CLICKHOUSE MERGETREE WE CAN GET 6 8 TIMES FASTER
EASY APPLICATION DOMAIN NOTHING TOO CHALLENGE
ECS WAS VERY UNIQUE TO ME BECAUSE OF THE WAY IT ORGANIZES THE DATA
EDGE DETECTION TAKES A HUGE BULK OF THE GENERATION TIME GOING FROM FIVE MINUTES TO 20 EVEN WITH 1 5 HOURS WITH CANNY
EFFORT IS IMPORTANT FOR WORKING PROFESSIONALS UNDER TIGHT DEADLINES
ELSE IF THE VALUE ON THE RIGHT IS BETTER THAN THEN WE ARE GOING TO TURN RIGHT AND THEN CONTINUE TO THE OUTER LOOP
ELSE WE'RE JUST GOING TO GO BACKWARDS
EMBEDDED HAL HAS A NUMBER OF TRAITS THAT DIFFERENT PIECES OF HARDWARE CAN IMPLEMENT
ENEMIES ARE RENTED WITH UNIQUE IDS
ENTER RFC THIS 2859
ENTERPRISE CAN BE KIND OF A BLACK BOX SO WE HAVE MADE EFFORTS TO MAKE SURE PEOPLE KNOW WHAT WE MAKE USING RUST AND WHAT IS RUST BEING USED FOR AND HOW ARE WE OPTIMIZING THE METAL FABRICATION SUPPLY CHAIN USING RUST
ENTIRELY IGNORED DURING THE DAY
ENTITIES HAS SPRITERENDER ATTACK HEALTH AND MOVEMENT ATTACHED
ENTITIES HAVE A NUMBER OF COMPONENTS ATTACHED TO THEM
ENUMS ARE ALSO UNAVOIDABLE
ENUMS IN OTHER OBJECT ORIENTED PROGRAMMING LANGUAGES DON'T HAVE THE SAME KIND OF ENUM VALUES AS RUST
ESPECIALLY AT HIGHER RESOLUTIONS
ESPECIALLY COMPARED TO OTHER LANGUAGES WHERE YOU MIGHT NEED AN EXTERNAL FRAMEWORK
ESPECIALLY FOR BEGINNERS
ESPECIALLY GIVEN THAT IT'S ALSO A LOW LEVEL PROGRAMMING LANGUAGE
ESPECIALLY IF I HAVE THE IMPRESSION THAT THEY ARE WHERE WE WHEN A NEW AND INTERESTING CONCEPT IN THE LANGUAGE
ESPECIALLY IF REQUIREMENTS CHANGE AND YOU HAVE TO REDO A BUNCH OF ANALYSIS WORK
ESPECIALLY IF WE ARE RUNNING ON SOMETHING LIKE A SIXTEEN BIT PLATFORM WHERE THIS WOULD CERTAINLY BE A BUG
ESPECIALLY IF YOU HAVEN'T WORKED WITH A SYSTEM PROGRAMMING LANGUAGE
ESPECIALLY THE POINT ABOUT CLIPPY
ESPECIALLY WHEN WE BUILD OUR OWN SOFTWARE FOR PEOPLE TO USE
ESPECIALLY WHEN YOU GET INTO LIKE THREADING AND POSING STYLE PROGRAMMING AND MANUAL STACK VERSUS HEAP
ESPECIALLY WHO WORK IN HAD RUST OPEN SOURCE
ESSENTIALLY THE CONSUMER CAN DECIDE WHICH LOG IMPLEMENTATION AND THE LOGGING LIBRARY WILL JUST USE THE API
EVAN'S BLOG POST THAT I MENTIONED AS WELL AS THE RUSTC DEV GUIDE
EVEN IF IT DON'T WE CAN ARGUE THAT THIS IS A GOOD THING BECAUSE IF YOU WANT TO ADD THIS KIND OF INTERACTIVITY FROM YOUR PROJECT IT WILL ALSO INCENTIVISE YOU TO MAKE YOUR CODE MORE PORTABLE AND MAKE IT COMPILABLE INTO A NEW TARGET
EVEN IF IT MEANS THAT THE PERFORMANCE AND THE FEATURES ARE NOT NECESSARILY OPTIMAL
EVEN IF THE SIMPLE SOLUTION MEANS MY ERROR VALUE IS A STRING
EVEN IF THOSE PROGRAMS DON'T HAVE ANY CHECK TO BE SURE THAT THEY'RE RUNNING CORRECTLY AND NOT DOING A LOT OF CHECKS LETS YOU SQUEEZE A LITTLE BIT OF PERFORMANCE WHEN YOU'RE WRITING YOUR PROGRAMS
EVEN IF WHEN DEALING WITH DATA WE ARE FACED WITH A CHOICE OF A MODEL OR A REPRESENTATION THAT WILL EXPLAIN IT
EVEN IF YOU DON'T NEED THAT SHIM MAYBE SOMEONE ELSE NEEDS IT AND YOU'RE NOT JUST TESTING THE UNDEFINED BEHAVIOUR YOU'RE HELPING EVERYONE WRITE BETTER AND SAFE CODE BECAUSE A LOT OF PEOPLE USE A BUNCH OF THINGS
EVEN IF YOU MULTIPLY TWO OF THE POWER OF EIGHT WHICH IS THE SIZE OF THE TIMER REGISTER IT WILL OVERFLOW IN A FEW MILLISECONDS
EVEN IF YOU'RE NOT USING UNSAFE YOU JUST WANT TO BE SURE YOUR PROGRAM RUNS AS INTENDED
EVEN THEN IF YOU DON'T FEEL COMFORTABLE YET CONTRIBUTING BECAUSE I DON'T KNOW YOU CAN HELP THIS PROJECT BY JUST USING IT
EVEN THOUGH SOMETIMES I ALSO THINK THEY'RE A LITTLE BIT
EVEN THOUGH THE NOTION OF SEARCH IN THIS PROJECT CAN BE ARGUED PURELY ALGORITHMICAL IT'S CLOSER TO A GENUINE ART PROCESS THAN WE MIGHT INITIALLY THINK
EVEN WHEN THAT LIMIT IS BOUND PRIMARILY BY THROUGHPUT AND TIME
EVERYBODY SHOULD FAMILIARIZE THE TOOLING
EVERYTHING IS SERIALIZATION
EVERYTHING WE JUST COVERED
EVERYTHING'S A BIT UP IN THE AIR WHEN YOU'RE RUNNING ON TIER 3
EXCELLENT
EXCEPT I'M NOT SURE IT IS
EXPLICITLY DESIGNED FOR NON EXPERT USERS
FAIRLY CONFIDENT IN RUST RIGHT
FANTASTIC
FEEL FREE TO CHECK THEM OUT TO MAKE SURE YOUR UNDERSTANDING IS CORRECT
FEEL FREE TO PAUSE WHEN THIS GOES ONLINE
FERROUS THANKS YOU AS WELL
FIELDS WHICH CONTAIN RAW DATA CAN BE MODELLED SO SOURCE PORT IS JUST SIXTEEN BIT UNSIGNED INTEGER
FIELDS WHICH COULD CONTAIN ONE OR MORE OF THE SAME ELEMENT COULD BE MODELLED AS AN ARRAY
FILE SYSTEM FORMATS LIKE MTFS ARE SERIALIZED BY THE CPU AND SENT TO THE HARD DRIVE AND BUFFERED TO BE SENT FOR THE GPU FOR DRAWING WHEN DATA IS FETCHED FROM RAM AT FETCH INSTRUCTION IS BYTES AND A SERIALIZATION FORMAT SENT OVER WIRES BETWEEN THE CPU AND RAM
FINALLY I DO A RECAP
FINALLY I SWITCHED OVER TO ANOTHER ARCHITECTURE WHICH WORKED
FINALLY THE NEXT VERSION OF TENSORBASE WE WILL HAVE MAIN OPERATORS ON SINGLE TABLE AND HAVE STORAGE LAYER V1
FINALLY WE ARE MOTIVATED TO HAVE A REFERENCE IMPLEMENTATION FOR ALGORITHMS THAT IS PORTABLE TO ARCHITECTURES THAT MIGHT NOT BE SUPPORTED BY HIGHLY OPTIMISED ASSEMBLE IMPLEMENTATIONS
FINALLY WE WRITE THE RUST TYPE DEFINITION FOR THE TCP HEADER STRUCT AND THE PARSER COMBINATOR TO PROCESS THE ENTIRE PROTOCOL DATA UNIT IN ONE FUNCTION CALL
FINE
FIRST A LITTLE BIT OF BACKGROUND I'M A FOURTH YEAR STUDENT AT NORTHEASTERN UNIVERSITY STUDYING COMPUTER SCIENCE AND BUSINESS ADMINISTRATION
FIRST A STEP HERE
FIRST AVR IS QUITE A NEW TARGET RIGHT
FIRST GRAPHQL
FIRST I WOULD LIKE TO COVER SOME OF THE TECHNICAL ASPECTS OF USING RUST SPECIFICALLY USING RUST IN THE DOMAIN DRIVEN DESIGN SENSE
FIRST I'M GOING TO GIVE A LITTLE OUTLINE OF THE TALK WITH THE MOTIVATION CHALLENGES AND SOLUTION
FIRST I'M GOING TO SHOW YOU A BIT WHAT IS SAFE AND WHAT IS UNSAFE
FIRST IN TYPESCRIPT AND THEN IN RUST
FIRST LET ME INTRODUCE MYSELF
FIRST LOGGING
FIRST OF ALL THE ECOSYSTEM IS GREAT THE PACKAGE MANAGEMENT IS HEAVENLY AND IF YOU JUST WANT TO GET STARTED ASAP LEARNING ABOUT OWNERSHIP IS ALL YOU REALLY NEED WHICH IS LITERALLY LIKE READING THE FIRST FOUR CHAPTERS OF THE RUST BOOK
FIRST OFF IS THE PARSING PHASE
FIRST OFF WE HAVE TO TALK A LITTLE BIT ABOUT HOW RUST C COMPILES THE CODE AND RUNS IT
FIRST RUST IS LIGHTNING FAST EVEN UNTUNED
FIRST THE IMPORTANT THING IS TO NOTE IF FEATURE IS A PACKAGE IT IS AN OPTIONAL DEPENDENCY OR A SET OF OTHER FEATURES
FIRST THE MAGIC NUMBERS THAT WE CALCULATED TOGETHER
FIRST THEY'RE GENERALLY MORE RATEABLE AND ACCESSIBLE TO DEVELOPERS AND REVIEWERS LEADING TO HIGHER QUALITY MORE SECURE CODE
FIRST WE WILL TALK ABOUT DEPENDENCY MANAGEMENT
FIRST WE WILL TALK ABOUT TIMING SIDE CHANNELS WORK WHAT THEY ARE WHY ARE THEY DANGEROUS
FIRST WRITE THE FIX
FIRST YOU HAVE TO KNOW ABOUT OUR PROBLEM WE ARE AN IN MEMORY REVISION CONTROL GRAPH DATABASE AND WE HAVE SLIGHTLY UNUSUAL FEATURES WHICH HAS DRIVEN SOME OF THE TOOL CHAIN REQUIREMENTS WE HAVE
FOCUS MY TIME ON MORE IMPORTANT THINGS
FOR ADVANTAGES IT FORCES A LOT OF GOOD HABITS WITHIN STUDENTS SIMPLY BY USING RUST AS THE LANGUAGE OF CHOICE
FOR ALL THE EXTRA TYPES WE IMPLEMENT ALL OF THE NORMAL ACCEPTABLE OPERATIONS
FOR ANYONE IN THE AUDIENCE NOT FAMILIAR THAT'S THE TARGET THAT THE RUST EMBEDDED INTRO BOOK TALKS THROUGH USING A BOARD CALLED THE DISCOVERY BOARD
FOR BOTH OF THESE CONSTRUCTERS WE CHANGED THE RESULTS TYPE
FOR CARGO IT IS THE FUTURE IN RUST
FOR COMPLETENESS LET'S LOOK INSIDE THE REGISTERS AND TALK ABOUT WHAT THE TYPES OF REGISTERS ARE
FOR CONCURRENCY IT IS EITHER GREAT
FOR DATA TYPES WE'RE GOING TO USE C STYLE STRUCTS
FOR EXAMPLE A SECRET KEY MAY BE AN ARRAY OF SECRET U8 BYTES AND KEEP US SECURE BY DISALLOWING ANY RUST CODE THAT WOULD RESULT IN INSECURE BINARY CODE
FOR EXAMPLE ELEMENT POSITION X
FOR EXAMPLE GO JAVA PYTHON WHERE I DO MORE PROGRAMMING
FOR EXAMPLE HERE
FOR EXAMPLE HERE THERE IS ALMOST NO GRADIENT INFORMATION AND THEREFORE THE BRUSHSTROKE MIGHT HAVE ANY ORIENTATION
FOR EXAMPLE I AM THE OWNER OF A LIBRARY AND I WANT TO OFFER PEOPLE A VARIANT OF MY LIBRARY
FOR EXAMPLE I'M USING UNO AND IF YOU GO TO EXAMPLES YOU CAN SEE HOW TO BLINK AN LED WHICH IS THE HELLO WORLD OF ARDUINO SYSTEMS
FOR EXAMPLE IF I GO BACK TO THE PROGRAM THAT OPENS THE FILE AND I TRY TO RUN IT WITH THE WINDOWS TARGET IT WILL FAIL BUT IT WILL FAIL BECAUSE THIS FUNCTION CREATEFILE W HASN'T BEEN IMPLEMENTED YET
FOR EXAMPLE IF WE LOOK AT DIGITAL PHOTO STUDIES WE CAN SEE A PROCESS OF SEARCHING FOR TEXTURES COLOURS FORMS THAT CONJURE A SIMILAR PERCEPTUAL RESPONSE TO THE TARGET PHOTOGRAPH
FOR EXAMPLE IN TEXTURE SYNTHESIS YOU CAN SEE PIXELS APPEARING FROM POSSIBLE NEIGHBOURHOODS IN THE EXAMPLE
FOR EXAMPLE IN THE IMAGE ON THE RIGHT THE ASCII DIAGRAM SHOWS THE OPTION REAL PORT IS 13 BITS LONG AND 19 BITS LONG BUT THE TEXT DESCRIPTION SAYS THESE SHOULD BE SIXTEEN BITS IN LENGTH
FOR EXAMPLE INSIDE A TCP PACKET A SERIALIZATION FORMAT YOU MAY FIND PART OF AN HTTP REQUEST
FOR EXAMPLE IT IS BECAUSE SOMETIMES WE JUST NOT LEAVE THE TIME FOR US
FOR EXAMPLE IT'S REALLY HARD TO BE DETERMINISTIC BECAUSE YOU CHANGE YOUR FILE THAT MIGHT CHANGE HOW EVERYTHING WORKED INTERNALLY
FOR EXAMPLE LEFT OFF IS A GREAT IDEA CONCEPT BUT SOMETIMES WHEN THE COMPILER NODES SELECT ESPECIALLY BEFORE THE IN IRR NO CODE LEFT IS INTRODUCED
FOR EXAMPLE MIRI DOESN'T SUPPORT CUSTOM ALLOCATORS AND IN THE LAST VERSION NOW THE POINTER ALLOWS FOR A CUSTOMER LOCATOR
FOR EXAMPLE MULTI CORES OR CODEGEN
FOR EXAMPLE PICASSO'S FAMOUS PAINTING THE LADIES OF AVIGNON IS THE RESULT OF HUNDREDS OF SKETCHES
FOR EXAMPLE RESOURCE MANAGEMENT OR THE ERROR HANDLING BUT FOR THE TIME LIMIT WITH ESCAPE
FOR EXAMPLE THERE'S AN ITEM WALL CALLED FREQUENCY AUGMENTER
FOR EXAMPLE THEY CAN OFFER A VARIANT WHERE THERE IS NO DEPENDENCY ON PRINTING ETC
FOR EXAMPLE THIS IS THE STACK TRACE WHEN YOU CALL FILE OPEN
FOR EXAMPLE TO CENTRE IT YOU NEED TO SET IT HIGH FOR 1 5 MILLISECONDS SO 1 5 DIVIDED BY 16 TIMES THE SIZE OF THE REGISTER IS 24 TICKS SO LET'S GO AND LOOK AT SOME CODE
FOR EXAMPLE WE DON'T ALLOW INDEXING BASED ON SECRETS WE DON'T ALLOW USING SECRET BOLL AND IF STATEMENTS
FOR EXAMPLE WHATEVER STEFAN TOLD YOU ABOUT ADDING AN INTEGER AND GOING OUT OF BOUNDS AND ADDING TOO MUCH TO YOUR INTEGER
FOR EXAMPLE WHEN I WROTE ABOUT A RUST PROGRAM WHAT I WORKED WITH THEM AND HAD TO REALLOCATE SOME MEMORY
FOR EXAMPLE YOU CAN'T HAVE ONE ENUM VALUE WITH AN INTEGER DATA FIELD AND ANOTHER ONE WITH A BOOLEAN DATA FIELD
FOR EXAMPLE YOU HAVE SOME DATA AND YOU CREATE A POINTER TO IT AND YOU DROP THE DATA IT GOES OUT OVER THE SCOPE IT'S DELETED
FOR EXAMPLE YOU READ A FILE AND YOU USE THE FILE TO I DON'T KNOW CREATE SOME CONST OR DEFINE A TYPE THAT IS GENERIC BUT THAT MAKES YOUR COMPILATION UNSOUND BECAUSE EVERY TIME YOU READ THE FILE
FOR FORMATTING RUST PROVIDES A TOOL THAT ALLOWS YOU TO STYLE YOUR RUST CODE ON OFFICIAL RUST GUIDELINES
FOR INSTANCE A FONT GLYPH A LETTER AND A FONT IT BASICALLY DEFINES A SOLED REGION BOUNDED BY A CURVE AND THE RENDERER HAS TO DETERMINE WHICH PIXELS ARE INSIDE OR OUTSIDE THAT CURVE AND THEN FILL THEM IN WITH THE APPROPRIATE COLOR
FOR INSTANCE AT THREE D SCENE
FOR INSTANCE IF YOU DO NOT MATH AND THE RESULT IS ZERO THE STATUS REGISTER WILL TELL YOU THAT THE LAST MATH YOU DID THE RESULT IS ZERO
FOR INSTANCE THE ATTINY 10 THAT YOU SAW ON THE VERY FIRST PICTURE OF THE AVR SLIDES THAT HAS 1 KILOBYTE OF PROGRAM MEMORY
FOR INSTANCE THE AVR DEVICES THAT I'M GENERALLY DEVELOPING FOR DON'T HAVE FLOATING POINT NUMBERS
FOR INSTANCE YOU COULD ASK THE COMPUTER TO COUNT TO A NUMBER
FOR INTEGERS WE'RE GOING TO BE USING THE I THIRTY TWO TYPE
FOR ME ESPECIALLY I DON'T THINK I WOULD HAVE STUCK WITH RUST AS LONG AS I HAVE WITHOUT RUST'S ERROR MESSAGES BEING AS KIND OF HELPFUL AND STRAIGHTFORWARD AND UNINTIMIDATING AS THEY ARE
FOR NUMBERS IN JAVA THE INSTRUCTORS USUALLY TEACH STUDENTS TO USE INT WHILE DOUBLE IS USED FOR FLOATING POINT PRECISION NEAR TERMS
FOR PART OF IT
FOR PEOPLE TRYING TO GET INTO PROGRAMMING FOR THE FIRST TIME
FOR POINT THREE PARTIAL COMPILATION IS A WAY TO MAKE THE COMPILATION TIME CORRELATE TO THE SIZE OF THE HOT KERNEL RATHER THAN THE TOTAL SIZE OF THE EXECUTION CODES
FOR POINT TWO YOU CAN SATURATE THE MEMORY BANDWIDTH OF THE IN CORE OF SUCH RUNS WITH 100 GIGABYTES PER SECOND MEMORY BANDWIDTH
FOR PRACTICAL THINGS IF SOME OF YOU ARE JUST GETTING STARTED WITH RUST OR HAVE WELL DONE SOME INITIAL LEARNING I CAN JUST GIVE YOU SOME HINTS FROM ME
FOR SURE
FOR TESTING AND DOCUMENTATION RUST SUPPORTS THESE AS FIRST CLASS CITIZENS
FOR THAT REASON IT'S PRETTY COMMON TO SEE THIS KIND OF PSYCHEDELIC IMAGE WITH UNICORNS AND A LOT OF COLOURFUL STUFF WHEN PEOPLE DISCUSS UNDEFINED BEHAVIOUR BECAUSE WHEN WE ARE DEALING WITH UNDEFINED BEHAVIOUR WE LOSE TRACK OF WHAT OUR PROGRAM IS DOING IN THE MOST BASIC LEVEL
FOR THE COMPUTER TO BE USEFUL IT MUST BE A COMPONENT CONNECTED TO A LARGER SYSTEM
FOR THE DOG CONSTRUCTER IT'S NEARLY IDENTICAL
FOR THE FINAL CASE STUDY I WOULD LIKE TO TAKE SOME TIME TO GO INTO HOW A NEW EXPERIMENTAL SERIALIZATION FORMAT CALLED TREE BUF REPRESENTS DATA IN A WAY THAT IS AMENDABLE TO FAST COMPRESSION
FOR THE FIRST INSTRUCT WE HAVE A COMMENT CALLED A HUMAN BEING AND INSTEAD OF THE PERSON WE HAVE NEW AND HELLO
FOR THE FREQUENCY AUGMENTER THIS DATA IS AN INCREASE IN THE FIRE RATE FOR THE PLAYER
FOR THE NEW FUNCTION WE HAVE AN EXPLANATION BUT ALSO ARGUMENTS AND EXAMPLES
FOR THE SPACE SHOOTER GAME WE MADE THE DECISION THAT FUNCTIONALITY THAT IS SPECIFIC TO AN ENTITY SHOULD BE CAMPAIGNED TO THE SPECIFIC COMPONENT
FOR THIS A GRAPHQL WAS MADE TO AN INDEXER FROM THE GRAPH FOR 1 000 RECENT WEARABLE ENTITY AUCTIONS
FOR THIS BENCHMARK WE WILL CONSIDER GEOJSON FOR SERIALIZING A LIST OF ALL THE COUNTRIES
FOR THIS CASE STUDY WE ARE GOING TO BE SENDING SOME DATA TO THE GPU
FOR THIS REASON IT WAS DIFFICULT FOR OTHERS TO CONTRIBUTE TO TOO
FOR THOSE TWO REASONS THOSE POINTERS MIGHT HAVE A LOT OF PROBLEMS AND MIGHT MISBEHAVE IN SEVERAL REASONS
FOR US WHAT WORKED AND HAS WORKED FOR THE LAST YEAR OR TWO IS THE FAMILIARITY WITH A TYPE SYSTEM WITH TRAITS AND GENERICS OR SOMETHING RESEMBLING THAT SUCH JAVA OR TYPESCRIPT AS WELL AS FUNCTIONS OF FUNCTIONAL PROGRAMMING AND FAMILIAR WITH COMPUTER ARCHITECTURE AND MANAGEMENT AND LOW LEVEL ASPECT OF HOW PROGRAMS RUN
FOR WE CAN DECIDE THE CONSTANT FOR HOW LONG DO WE WANT OUR CAR TO TURN
FOUND A BUG IN THE COMPILER
FROM OUR PLAN
FROM OUR WORKING CODE
FROM THE USER PERSPECTIVE IT CAN HAPPEN SO FAST THAT IS MIGHT NOT SEEM LIKE A SEARCH
FROM WHATEVER WAS THERE BEFORE RIGHT
FURTHERMORE FUTURE CONCEPTS WILL ENFORCE GOOD HABITS WITHIN STUDENTS WHO ALSO HAVE THE OPTION TYPE LIFETIMES AND MUTABILITY AND�THREAD SAFETY AND ALL OF THESE THINGS WHICH ARE INCLUDED IN RUST EITHER IN THE STANDARD LIBRARY OR IN THE CORE LIBRARY OR AS A LANGUAGE FEATURE WHICH STUDENTS WILL BE ABLE TO TAKE ADVANTAGE OF
FUTURE INSIGHTS
GAVIN AND MATTHIJS SHOW HOW ONE MIGHT
GDB PROVIDES VARIOUS OTHER FEATURES
GENERALLY THE REASON IS NOT A NUMBER OR THE INFINITY VALUES MIGHT BE TRICKY TO HAVE A TOTAL ORDERING BECAUSE THE NAN OR NON NUMBER VALUE IS NOT EQUAL TO ITSELF
GENETIC ALGORITHM IS A SEARCH ALGORITHM LOOSELY INSPIRED BY NATURAL SELECTION
GEO JSON IS A COMPACT FORMULA BECAUSE IT DOESN'T DESCRIBE EACH POINT WITH REDUNDANT TAGS LIKE LONGITUDE AND LATITUDE REPEATED OVER AND OVER BUT INSTEAD OPTS TO SCORE THAT DATA IN A GIANT NESTED ARRAY TO MINIMIZE OVERHEAD
GIVEN A REPRESENTATION IN TIME LIMIT THE SET OF INPUTS AND CALCULATED OUTPUTS EXPRESSED WITHIN THOSE BOUNDS IS FINITE
GIVEN INPUT AND OUTPUT DATA REPRESENTATIONS AND AN ALGORITHM SITTING IN BETWEEN A CONTAINING TO EITHER REPRESENTATION NECESSITATES A CORRESPONDING CHANGE TO THE ALGORITHM AND NOTE THAT THE INVERSE IS NOT ALWAYS TRUE
GIVEN THE COMPARATIVE AGE OF ALL THE LANGUAGES RUST IS RELATIVELY YOUNG
GIVING COMPONENTS THEIR OWN STORAGES ALLOWS FOR FASTER ACCESS TO DATA NEEDED WHEN UPDATING AN ENTITY'S COMPONENT STATE
GIVING THEM A LOT OF SKILLS THAT THEY CAN USE THROUGHOUT THE INDUSTRY
GLAD YOU LIKED IT
GLOWCOIL SHOWS HOW VECTORS CAN ACT
GNU PROJECT DEBUGGER ALLOWS YOU TO UNDERSTAND WHAT IS ON IN THE PROGRAM WHILES IT IS EXECUTING
GO OVER THESE
GOING BACK TO SHOW THE MODEL I THINK THIS IS THE ONLY THING THAT I DIDN'T SHOW
GOING BACK TO THE FREQUENCY AUGMENTER ITEM WHEN IT'S COLLECTED IN THE SPACESHIP ITEM COLLISION SYSTEM IT INITIALIZES AN EVENT AND SENT TO THE EVENT CHANNEL TO THE SPACESHIP SYSTEM WHERE THE ATTRIBUTES CAN BE ADDED TO THE SPACESHIP THAT COLLECTED IT
GOOD
GOOD AFTERNOON
GOOD DAY EVERYBODY
GOTCHA
GPUS ARE REALLY GOOD FOR HIGHLY PARALLEL TASKS
GREAT
GREAT TALK
GREAT TO BE HERE
GREAT TO FAIL OR TO RUN
GROWING FROM THE ROOF OF A CAVERN
GROWS DOWN INTO MEMORY
GZIP SECOND WITH A SCORE OF 0
HAD A WORD X ET CETERA
HAND WAVING A BIT HERE
HANDLING THIS COLOR IS EASY WITH A MATCH STATEMENT
HAS AN ADVANTAGE THAT YOU CAN ACTUALLY BUILD HIGHER IN TERMS OF KNOWLEDGE
HAS THE IETF BEEN RECEPTIVE TO THE MACHINE READABLE DIAGRAM FORMAT
HAVE A GOOD DAY
HAVE AN AWESOME REMAINDER OF RUSTFEST
HAVE AN EQUIVALENT IN RUST
HAVING A WAY TO TRACK DISCUSSIONS AROUND REFACTORING DECISIONS WAS ONE OF THE BEST WAYS TO CAPTURE THOUGHT PROCESSES
HAVING AN ACTUALLY CORRECT IMPLEMENTATION THAT IS DONE WHEN THE SPECIFICATION IS FINISHED
HAVING COMPONENTS REUSABLE BETWEEN ENTITIES IS WHAT ECS STRIVES TO DO
HAVING ESTABLISHED THAT WRITING THE DATA IS THE PROBLEM WE ARE TRYING TO SOLVE AND THE CHARACTERISTICS THE SERIALIZATION FORMAT MUST HAVE BECAUSE OF THE GPU ARCHITECTURES LET'S WRITE A PROGRAM TO SERIALIZE THE DATA
HAVING THAT CONFIDENCE THAT IF MY CODE COMPILES IT WORKS
HAVING THE RUST ECOSYSTEM IS ALSO A REALLY IMPORTANT THING
HAVING THOSE IS SO HARD TO AVOID TEACHING ABOUT STACK VERSUS THE HEAP
HAVING THOSE STANDARD LIBRARIES BASED ON A GLOBAL ALLOCATOR PROBABLY OUTWEIGHS THE TECHNICAL BENEFITS FOR THESE NICHE USE CASES
HE TALKS ABOUT A LOT OF THINGS IN THE SAME TERM SO THAT'S INTERESTING
HELLO
HELLO AND WELCOME TO RUSTFEST GLOBAL 2020
HELLO EVERYBODY
HELLO EVERYONE
HELLO EVERYONE MY NAME IS TARUN AND IN TODAY'S TALK WE WILL COVER THE BASIC PRINCIPLES AND TOOLS TO GET STARTED WITH RUST WITHOUT HAVING TO DO IT THE HARD WAY
HELLO I'M AISSATA MAIGA JUST YOUR REGULAR COMPUTER SCIENCE STUDENT AND I LIVE IN SWEDEN
HELLO MY NAME IS VIVIAN BAND
HER BOT TO MY GROOVE
HER THE STUFF UNDERNEATH
HERE ARE SOME COMPARISONS OF HOW LONG IT TAKES FOR DIFFERENT EDGE DETECTION ITERATIONS AVAILABLE IN DIFFERENT RUST CRATES
HERE ARE THE RESULTS
HERE CLOSER TO THE EDGES THERE IS A STRONG DIRECTIONALITY INDICATED BY THE LENGTH OF THE LINES AND THE BRUSHSTROKES PLACED HERE ARE MORE LIKELY TO FOLLOW ALONG THE FIELD'S DIRECTION
HERE I DISCOVERED A GAME ENGINE AMETHYST THAT USED AN UNFAMILIAR ARCHITECTURE ECS
HERE I HAVE AN EXAMPLE WHERE WE HAVE A VARIABLE SET TO 0
HERE I HAVE INTERESTING STATISTICS ABOUT THIS
HERE IN JAPAN ONE OF THE WAYS THAT WE HAVE DECIDED TO DO HIRING IS TO LOOK FOR THE CORE ASPECTS OF WHAT ARE THE ATTRIBUTES THAT MAKE SOMEBODY A GOOD RUST ENGINEER
HERE IN MY TERMINAL I HAVE THIS TINY CRATE
HERE IS A CPU WITH COMPONENTS FOR INSTRUCTIONS TO CODING BRANCH PREDICTIONS CACHES AND SCHEDULEERS
HERE IS A DEPICTION OF THAT
HERE IS A PICTURE OF THE INSIDE OF A COMPUTER
HERE IS A PICTURE OF THE INSIDE OF A COMPUTER SUB SYSTEM COMPRISEING SEVERAL COMPONENTS EACH DRIVEN BY DATA SENT OVER THE WIRES THAT CONNECT THE COMPONENTS
HERE IS A PRETTYPRINTED HIR
HERE IS A SCREENSHOT OF THE PHABRICATOR INTERFACE THAT LLVM USES
HERE IS A TENSORBASE GENERATED KERNEL THAT YOU CAN COMPARE WITH THE KERNEL SOURCE FROM PAPER
HERE IS A TYPE FROM THE GRAPHQL PARSER CRATE
HERE IS A VISUAL REPRESENTATION OF THAT
HERE IS AN ARCHITECTURE OF TENSORBASE
HERE IS AN EXAMPLE OF SOME LOGS THAT WERE INSTRUMENTED USING THE LOG GRID
HERE IS AN EXAMPLE THAT WE MADE TO TAKE A QUICK LOOK
HERE IS AN EXAMPLE USING THE MACROS FROM THE LOG GRID AND IN THE THIRD LINE WE ARE USING TO REPORT ACTION
HERE IS JUST A PIPER
HERE IS SOMETHING SUPER IMPORTANT THAT MIRI CANNOT INTERPRET PROGRAMS THAT AREN'T RUST PROGRAMS
HERE IS THE SAME IMAGE AS BEFORE
HERE IS WHERE WE DO THAT
HERE MBBI STARTS WITH THE END OF THE FUNCTION AND AS LONG AS WE HAVEN'T REACHED THE BEGINNING OF THE FUNCTION WE STEP BACKWARDS THROUGH THE FUNCTION
HERE THE COMMENTED OUTLINE FOR PHYSICAL COLOR SAMPLE IN THE MATCH STATEMENT WOULD GENERATE A COMPILER ERROR AND SO IF SOMEBODY MODIFYING THE DOMAIN MODEL OR THE ACTUAL STRUCT DID NOT REALIZE ALL OF THE PLACES WHERE IT WAS BEING USED WE COULD SIMPLY ASK THE COMPILER TO DETECT IT FOR US
HERE THE PROGRAMMER CHOSE TO BRANCH ON A SECRET BOOL
HERE TOO THE PHYSICAL SEPARATION OF EACH COMPONENT ASIDE FROM THE WIRES CONNECTING THEM NECESSITATES THE DATA WHICH DRIVES EACH COMPONENT TO BE SERIALIZED IN WELL SPECIFIED AGREED UPON FORMATS
HERE WE ARE INSTRUMENTING THE CONNECT TWO FUNCTION WITH THE INSTRUMENT ATTRIBUTE
HERE WE HAVE AN EXAMPLE WITH A VECTOR WITH THREE ELEMENTS AND WE'RE GOING TO TRY TO ACCESS THE TENTH ELEMENT
HERE WE HAVE AN IMPLEMENTATION WITH TWO FUNCTIONS
HERE WE HAVE SOME POTENTIALLY SURPRISING CODE WHERE WE'RE ADDING 1 TO ITSELF THREE TIMES
HERE WE HAVE THE UNSAFE FUNCTION CALLED GET UNCHECKED
HERE WE SEE
HERE WE USE THE GDB TOOL TO COMPILE THAT
HERE WE'RE TRYING TO CONVERT BETWEEN A THIRTY TWO BIT UNSIGNED INTEGER AND CONVERT IT INTO THE PLATFORM'S SIZE OF INTEGER AND RUST IS NOT HAPPY HERE EITHER BECAUSE IT WANTS US TO DO AN EXPLICIT CONVERSION WHERE WE TRY AND
HERE WITH MORE SPARKS WE SEE A LASER CUTTER WHICH USES HIGH INTENSITY LASER BEAMS TO CUT SHAPES OUT OF SHEETS OF METAL
HERE WITH TENSORBASE CAN DO THE END TO END INQUERY IN THE 6 TO 10 TIMES FASTER THAN C PLUS PLUS OR OLAP DATABASE
HERE YOU CAN SEE THE BEGINNING OF A SEARCH AS BRUSHES MOVE AROUND TRYING TO POSITION THEMSELVES IN SUCH A WAY THAT LOOKS MORE LIKE A TARGET AND IF IT CONTINUES ITS GUIDE THE SEARCH LONG ENOUGH WE WILL EVENTUALLY REACH A CAN VARIOUS CONFIGURATION WHOSE BRUSHSTROKE ARRANGEMENT LOOKS SIMILAR TO THE TARGET
HERE YOU CAN SEE THE SEARCH PROCESS HAPPENING FOR DIFFERENT STAGES
HERE'S A COMPARISON OF USING VERSUS NOT USING EDGES TO GUIDE THE SEARCH
HERE'S A PYTHON EXAMPLE
HERE'S AN EXAMPLE OF A C PLUS PLUS ERROR MESSAGE
HERE'S BACKGROUND
HERE'S THE BROKEN CODE BEFORE WE INSERT OUR FRAME POINTER RESTORATION
HERE'S WHAT I RUST C THINK IS WRONG
HEY I'M MICAH A SOFTWARE ENGINEER AT MOZILLA
HI
HI AND WELCOME TO RUST FOR ARTISTS ART FOR RUSTACEANS
HI EVERYONE WELCOME TO OUR TALK ON HOW TO REVIVE A DEAD RUST PROJECT
HI I'M DIANE HOSFELT AND THIS IS BATMAN
HI I'M MICAH JOHNSTON
HI I'M NIKITA AND TODAY I'M GOING TO SHARE WITH YOU A DIFFERENT APPROACH TO WRITING DOCUMENTATION AND EDUCATING PEOPLE ABOUT PROGRAMMING IN RUST
HOMEWORK IS TYPICALLY SUBMITTED AS LIBRARY FILES
HOORAY
HOPE YOU FOUND THAT INSIGHTFUL
HOPEFULLY A LITTLE BIT LESS INTIMIDATING WHERE YOU KNOW YOU
HOPEFULLY I SUCCEED AT THAT
HOPEFULLY WE CAN MAKE THIS WORK
HOPEFULLY WE HAVE A COUPLE MINUTES TO TAKE A FEW QUESTIONS IF ANYONE WOULD LIKE TO HEAR ANYTHING MORE
HOPEFULLY YES
HOPING TO RELEASE IT ON CRATES IO
HOW ABOUT NOW
HOW ARE THOSE COLLECTIONS USED
HOW ARE YOU FINDING IT AND HAVE YOU TRIED THINGS LIKE ST 32 TARGETS
HOW CAN THEY BE USED FOR THE COMPLEX COMBINATORS IN RUST
HOW CAN WE FIX THIS
HOW DO WE GET THE DATA FROM THE COLLISION DETECTION SYSTEM INTO THE SPACESHIP SYSTEM
HOW DOES IT DO ON COMPRESSION AND PERFORMANCE
HOW DOES THE ALGORITHM WORK
HOW FAR CAN IT TRACK STUFF RIGHT
HOW HELPFUL BETTER ERROR MESSAGES ARE BASICALLY
HOW IS THE CODE PART SEPARATED ESSENTIALLY
HOW IS THIS POSSIBLE
HOW IT WORKS FROM AN API DESIGN STANDPOINT
HOW LONG DO YOU WANT OUR BOT TO WAIT BETWEEN ACTIONS THE MINI DISTANCE YOU WANT TO HAVE BETWEEN ITSELF AND AN OBSTACLE AND WHAT IS AN ACCEPTABLE DISTANCE TO MAKE AN ALTERNATIVE CHOICE
HOW SINGLETON
HOW TO BE A GOD BAT
HOW TO KEEP THE SYSTEM LEAN AND FOCUSED WHILE AT THE SAME TIME ALLOWING THEM TO DETECT IF AN ITEM IS COLLECTED
HOW TO MAKE BOTS WITHOUT ARDUINO
HOWEVER EVEN AFTER ALL OF THIS PEER REVIEW FROM SEVERAL DIFFERENT SOURCES MISTAKES STILL SOMETIMES APPEAR IN THESE DOCUMENTS
HOWEVER EVEN WHEN PAINTING FROM REFERENCE WITH A GOAL OF COPYING REALITY IT IS NEVER A PASSIVE OBSERVATION BUT ACTIVE INTERPRETATION AND ENGINEERING OF USUAL FORMS WHICH TOGETHER CONSTRUCT A PRESENTATION
HOWEVER FOR THE PURPOSES OF THIS WE ARE GOING TO FOCUS ON THE FIRST TWO BECAUSE THOSE ARE LIKE THE MORE COMMON MOST LIKELY ANY OF US HAS BEEN EXPOSED TO ONE OF THIS AT ONE POINT
HOWEVER IF WE DIG DEEPER WE WILL DISCOVER THERE IS ALWAYS AN UNDERLYING NETWORK OF TRIAL AND ERROR
HOWEVER OF COURSE THE TYPE SYSTEMS ARE NOT EXACTLY THE SAME IN RUST AND TYPESCRIPT SO THERE IS A LITTLE BIT OF MESSAGING WE NEED TO DO TO PAC SURE WE CAN HANDLE IT BUT RUST AND TYPESCRIPT HAVE SIMILAR NOTIONS AND THAT HAS BEEN INSTRUMENTAL IN OPTIMIZING OR TO INCREASE THE EFFICIENCY OF OUR DEVELOPMENT PROCESS
HOWEVER THERE'S A LOT OF FEATURES THAT WE EXPECT WILL END UP IN RUST AS WE MOVE FORWARD AND THEY REALLY IT'S GOING TO BE A SLOW REPLACEMENT STRATEGY
HOWEVER WE HAD A LOT OF TROUBLE WITH THIS AND IT WAS A PERSISTENT SOURCE OF PAIN SO C PLUS PLUS WAS CRASHING REGULARLY AND THIS IS PARTLY BECAUSE WE NEEDED WE HAD REQUIREMENTS THAT WE HAD TO BE MULTITHREADED FOR PERFORMANCE REASONS BECAUSE WE WERE DEALING WITH VERY VERY LARGE DATABASES IN THE BILLIONS OF NODES AND THE CODE WAS NOT RE ENTRANT ALTHOUGH IT WAS SUPPOSED TO BE WRITTEN WITH THE INTENT OF BEING RE ENTRANT BUT IT WASN'T IN PRACTICE AND THIS WOULD COME UP WITH THE SERVER CRASHED
HOWEVER YOU CAN DO YOURSELF RUN LARGE FAVOR AND TRY NOT TO DO TOO MUCH AT THE BEGINNING
I
I ADD IN A LITTLE BIT OF SUPPORT FOR THE BUTTON PART
I AGREE
I ALSO
I ALSO CAN'T RECOMMEND ENOUGH GETTING RUST ANALYZER IT WILL SHOW YOU TYPES TIPS IT IS ABSOLUTELY AMAZING
I ALSO GO BY THE USERNAME GLOWCOIL
I ALSO PRODUCE A PODCAST CALLED THE HUMANS OF OPEN SOURCE WHERE I TALK TO PEOPLE WHO WORK IN OPEN SOURCE SOFTWARE
I ALSO TRY TO CONTRIBUTE TO PROJECTS IN RUST LIKE THE TRACING PROJECT
I ALSO WANT TO LIMIT THE USE OF CARGO SINCE DEPENDENCIES AND COMPILER CONFIGURATION OPTIONS ARE NOT REALLY NECESSARY FOR STUDENTS FIRST LEARNING HOW TO CODE
I ALSO WANT TO SHOW YOU A SUPER COOL THAT CAN HELP YOU WRITE BETTER CODE
I ALWAYS USE A LITTLE THING WHEREVER I GO OF A COUPLE OF HUNDRED FILES ON MY FILE SYSTEMS AND COUNTS OF WORDS AND GIVE ME THE MOST FREQUENT ONES
I AM EVEN IN THE WAY OF SOME OF THESE
I AM GOING DESCRIBE THE CODE BUT DON'T WORRY ABOUT FALLING TOO MUCH
I AM GOING TO STICK AROUND IN THE CHAT SO IF ANYONE HAS QUESTIONS THERE I WILL ANSWER THEM
I AM NOT SAYING TO AVOID GRAPHQL
I AM SORRY I DIDN'T MAKE IT AS ACCESSIBLE AS PLANNED
I AM SORRY IT WASN'T AS EASY TO FOLLOW AS I HOPED WHEN I PLANNED FOR THE TALK
I AM USING RUST TOOL CHAIN TO INSTALL A SPECIFIC VERSION
I APOLOGIZE
I BASICALLY LOOKED AT THE APPLICATIONS THE DIRECT APPLICATION
I CALL IT SPARSE SCANLINE RENDERING
I CAN FIGURE OUT HOW IT WORKS
I CAN REMEMBER WHEN I FIRST STARTED TO LEARN PROGRAMMING WHICH WAS IN JAVASCRIPT THAT WAS KIND OF LIKE MY FIRST LANGUAGE THAT I REALLY TRIED TO LEARN
I CAN TAKE THIS ONE
I CAN'T COMMENT ON IT
I CAN'T IMPRESS UPON PEOPLE ENOUGH HOW AWESOME THIS IS AND HOW MUCH WE NEED OTHER PEOPLE TO START USING IT
I CAN'T THINK OF A SITUATION WHERE I WOULDN'T
I CAN'T THINK OF ANY
I CLAIM IT IS EASIER TO USE TREE BUF THAN GZIP
I COLLECTED IT TO PIN D11
I COULDN'T
I COULDN'T NAME ANY OFF OF THE TOP OF MY HEAD RIGHT NOW
I CREATED THE SERVO UNIT WHICH WAS TO WORK WITH RUST STRUCTURES
I DID FIND IT A STRUGGLE TO KIND OF GET THE IDEAS DOWN INTO SOMETHING LIKE A SMALL PACKAGE AND REALLY PRESENT THEM
I DID SOME UNPACKING HERE
I DID WHAT ANYBODY WOULD DO AND ASKED GOOGLE IMAGE SEARCH WHAT METAL FABRICATION WAS
I DIDN'T COME FROM A RUST BACKGROUND AND ALTHOUGH I HAVE A LOT OF EXPERIENCE IN DIFFERENT PROGRAMMING LANGUAGES RUST WAS NOT ONE OF THOSE PROGRAMMING LANGUAGES
I DIDN'T KNOW TO BECAUSE THERE WERE INFREQUENT CONTRIBUTORS BESIDES ME ALONE
I DIDN'T WANT TO INTRODUCE THE ENUM SINCE THIS ISN'T EVEN INTRODUCED FOR JAVA IN FUNDIES�2
I DIDN'T WANT TO TELL EVERYBODY WE'VE DONE IT RIGHT WE'VE DONE SOME THINGS RIGHT BUT WE CAN IMPROVE A LOT HERE
I DISCOVERED RUST THIS SUMMER AND FELL IN LOVE WITH IT
I DO SO TO PRESERVE THE LOOSE BRUSH WORK WHILE GIVING A PERCEPTION OF A DELIBERATE INTENT
I DO THINK THAT THERE'S A LOT ABOUT THAT KIND OF STUFF THAT'S A LITTLE BIT MORE COMPLICATED FOR STUDENTS TO LEARN ESPECIALLY IN THEIR FIRST YEAR OF LEARNING COMPUTER SCIENCE
I DON'T DO THIS TO DESPAIRAGE TYPESCRIPT
I DON'T HAVE MORE TO SAY ON THAT
I DON'T HAVE WINDOWS INSTALLED HERE
I DON'T KNOW A LOT OF
I DON'T KNOW ABOUT YOU
I DON'T KNOW HOW MIRI WORKS
I DON'T KNOW HOW YOU COULD DO THAT
I DON'T KNOW IF I COULD ADD ANYTHING TO THAT
I DON'T KNOW IF RUST ANALYZER IS WORKING ON THAT
I DON'T KNOW IF YOU CAN DO THAT IN LLVM IR
I DON'T KNOW MAYBE YOU WANT TO HAVE A FRIDGE THAT COMMENTS IF YOU OPEN IT AT NIGHT
I DON'T KNOW WHAT HAPPENED WITH THAT PROJECT
I DON'T SEE ANY MORE QUESTIONS
I DON'T THINK THERE ARE OPEN QUESTIONS YET
I DON'T WITH THAT
I DON'T WORK FULL TIME I JUST DO IT WHEN I HAVE FREE TIME
I DON'T WORK ON COMPLEX SYSTEMS
I DOVE INTO EMBEDDED RUST WITH A REMOTE CONTROLLED ROVER
I ENDED UP ENCOUNTERING THE SAME PROBLEMS
I EVEN JOINED THE COMMUNITY AND EARLIER THIS YEAR I BECAME AN EDITOR FOR THIS WEEK IN RUST
I FIND IT EASIER TO UNDERSTAND WHAT ECS IS THROUGH A SERIES OF EXAMPLES
I FIND MYSELF WRITING UNIT TESTS MUCH MORE FREQUENTLY IN RUST THAN I DO IN C PLUS PLUS WHERE IT'S A LITTLE BIT MORE TRICKY
I FIRST STARTED LEARNING RUST IN THE SPRING OF 2019 WHILE I WAS TAKING COMPUTER SYSTEMS A COURSE TAUGHT IN C
I FOLLOWED HER LEAD AND LEARNED FOR MYSELF HOW TO USE THE COLLABORATIVE TOOLS
I GET DYLAN MCKAY FORTUNATELY HAD THE TIME TO REVIEW MY PATCH AND COMMITTED IT
I GO TO THE SAME EXAMPLE AND I CLICK ON THE RUN BUTTON
I GOT STARTED WITH RUST TWO YEARS AGO AS AN ON AND OFF HOBBY
I GUESS PEOPLE HAVE OTHER THINGS TO DO
I GUESS YOU WILL BE TRYING TO INVESTIGATE LIKE THE CORRECTNESS OF THE MIDDLE BOXES AND WHAT NOT OR MAYBE TRY TO CIRCUMVENT THEM
I HAD HEARD OF RUST BUT I HAD NOT WRITTEN ANYTHING IN RUST
I HAD IT AROUND HERE SOMEWHERE
I HAD TO DO THESE BABY STEPS TO SLOWLY RAMP UP
I HAD USED RUST EARLIER TO IMPLEMENT A BEAR BONES VERSION OF THE PROTOCOL A FEW YEARS AGO ON MY FINAL YEAR UNDERGRAD PROJECT AND I WAS IMPRESSED HOW MUCH SAFETY IT ADDED TO THE SYSTEM'S PROGRAMMING
I HAVE
I HAVE A MINIMAL REPRO
I HAVE A PROBLEM WITH THIS THOUGH
I HAVE A QUESTION
I HAVE ANOTHER QUESTION
I HAVE CHOSEN THIS FORMAT BECAUSE MESSAGE PACK IS SMALLER AND FASTER THAN JSON AND IS SELF DESCRIBING LIKE JSON WHICH WORKS WELL FOR GRAPHQL
I HAVE CONTRIBUTED TO OPEN SOURCE RUST PROJECTS AND A FEW TOY PROJECTS
I HAVE DONE A LITTLE BIT OF ARM DEVELOPMENT
I HAVE GROUPED THEM TOGETHER WITH THE ENTITY THEY ARE ASSOCIATED WITH
I HAVE MY
I HAVE NO IDEA
I HAVE NO IDEA WHY AND I CHANGED SOMETHING ABOUT IT
I HAVE NOT YET EXPERIMENTED WITH USING THE ALLOCATOR
I HAVE ON MY LIST OF TOO MANY THINGS TO DO I HAVE THE GOAL OF PICKING UP ONE OF THOSE DISCOVERY BOARDS AND WORKING THROUGH THAT
I HAVE SEEN
I HAVE STARTED A PROJECT THAT CONTAINS THE DOCKER IMAGE FOR THE COMPILER SERVICE AND SOME FRONT END COMPONENTS
I HAVE TO DECIPHER WHAT THIS IS ACTUALLY SAYING
I HAVEN'T DONE THE STM 32
I HAVEN'T HAD TIME TO YET
I HAVEN'T TOLD YOU ANYTHING ABOUT HOW GO WORKS BUT BY WATCHING THE MOVIE YOU MIGHT PICK UP ON SOME PATTERNS IN THE DATA
I HIGHLY RECOMMEND CHECKING OUT THAT
I HOPE I HAVEN'T MISSED ANY
I HOPE IT WAS USEFUL AND YOU LEARN SOMETHING NEW AND IF YOU HAVE ANY QUESTIONS WRITE A COMMENT IF YOU'RE WATCHING IT OFF LINE OR POST A MESSAGE IN THE CHAT IF YOU'RE WATCHING IT LIVE
I HOPE PEOPLE ARE TUNING INTO THE Q AN A TO GET TO SEE THIS
I HOPE TO LEAVE TIME TO ASK QUESTIONS BUT IF NOT YOU CAN REACH OUT
I HOPE YOU FOUND THIS INTERESTING AND I THINK WE CAN DO SOME QUESTIONS NOW IF YOU WANT
I HOPE YOU KNOW THAT'S WHY I LOVE YOUR MENTORING WORK AS WELL YOU MENTIONING THAT AND SHARING SO MUCH WITH US BECAUSE YOU'RE ENCOURAGING OTHER PEOPLE TO FEEL SAFE GO FOR IT ALSO TRY IT AND THAT IS AMAZING
I JUST EXPLAINED THE MAGIC NUMBERS BECAUSE I KNOW SOME OF YOU ARE INTERESTED IN THEM
I JUST MOVED INTO JUST PUSHINGSO STRUCTS AROUND AND THEN USING CLONE A LOT
I JUST REMOVED IT FROM THE PRESENTATION FOR CLARITY
I KNOW A LOT OF LANGUAGES HAVE LEARNED KAM C PLUS PLUS HASKELL PROLOG LISP I'VE BEEN THROUGH THE GAMUT OF ALL OF THESE AND I DON'T TRY TO LEARN A NEW LANGUAGE UNLESS THERE IS SOMETHING PECULIAR THAT DRIVES IT AS SOMETHING YOU MIGHT NEED IN YOUR TOOL KIT
I KNOW ENOUGH TO SPEAK FULLY TO THAT
I KNOW IT USES LIKE THE SAME DESIGN PHILOSOPHY
I KNOW PEOPLE WHO HAVE BEEN IN THE INDUSTRY FOR YEARS AND YEARS AND THEY'RE TOO SCARED TO MAKE PRS TO PUT THEIR STUFF OUT THERE SO THAT IS REALLY COOL
I KNOW THAT YEAH THEY'RE SWITCHING FROM LIBRARY CALLED SPECS TO LEGION
I KNOW THERE ARE A LOT ON GDB YOU CAN USE BUT I AM NOT SURE I CAN ADD ANYTHING HERE
I KNOW THIS CONCEPT
I KNOW THIS CONCEPT I KNOW THIS CONCEPT
I KNOW WE ARE MULTI CULTURED AND EVERYTHING AND EVERYONE MIGHT NOT BE ON THE SAME TECHNOLOGICAL OR ENGLISH SPEAKING LEVEL
I KNOW WE HAVE 25 TO 40 SECOND DELAY TO THE STREAM SO JUST TO GET AHEAD OF TIME I HAVE TWO QUESTIONS IF YOU DON'T MIND
I LIKE HOW YOU MENTION WHERE TO GET THINGS AND HOW TO SPOT FAKES
I LIKE TO CALL IT THE GL LINES GOBRRRR ARCHITECTURE
I LIKE TO THERE ARE FUNCTIONS FOR ROTATION AS WELL AS SCALE AND TO CHANGE VALUE WE CAN SIMPLY ACCESS PIXEL DATA
I MADE TWO INFORMAL DOCUMENTS WHEN MICAH JOINED
I MAY NOT HAVE GRASPED THIS NOW
I MEAN I ALSO WRITE GO AND I THINK IT'S A GREAT LANGUAGE
I MEAN IF IT IS FAIR AT ALL I THINK IT WAS VERY CLEAR
I MEANT THE SENSOR IS WORKING LIKE A BAT AND WELL LET'S JUST FORGET THAT
I MENTIONED GRAPHQL IN THIS EXAMPLE BECAUSE USING A STANDARD FORMAT TO ILLUSTRATE THIS PROBLEM IS EASIER FOR ME THAN JUST INVENTING ONE FOR THIS CAUTIONARY TALE
I PULL OUT A FUNCTION TO RESTORE THE STATUS REGISTER FROM THIS SPECIAL EPILOGUE CODE
I PUT THE WHEELS INTO A NEW ARRAY TO MAKE SURE THAT I WROTE IT CORRECTLY AND THEN YOU JUST NEED WHEN YOU GO FORWARD YOU JUST NEED TO SET FORWARD THE MOTION THE LEFT AND RIGHT FORWARD MOTION HIGH AND THE RIGHT AND BACK MOTION LOW
I READ THROUGH THE AMETHYST BOOK AND FOLLOWED TUTORIALS AND STARTED WORKING ON MY OWN GAME SPACE SHOOTER RS
I REALLY APPRECIATED BEING HERE
I REALLY LIKE RUST AND I DIDN'T KNOW WHERE TO START
I REMEMBER I READ SOMEONE WAS WRITING AN INTERPRETER FOR SO YOU CAN USE IT LIKE WAS A REBEL
I SAID I WAS EXCITED ABOUT THIS TALK BUT WOW
I SAID I'M USE�INTERRUPTS
I SAID THAT AVR INTERRUPTS ARE EXPERIMENTAL
I SAY ALMOST BECAUSE THERE IS A FUNDAMENTAL LIMITATION TO THE GRAPHQL THAT NO AMOUNT OF RUST FEATURES OR LIBRARY APIS COULD OVERCOME
I SAY LIKE OKAY I COULD IMPLEMENT MAYBE LIKE SOME FOREIGN FUNCTIONS FOR OPENING FILES WHATEVER IT SOUNDS NOT TOO HARD
I SAY MVPS BECAUSE I WROTE TWO BASED ON THE TWO DIDN'T SCOPES FOR THE PROJECT
I SAY SOMETHING ABOUT THE SOUND AND I JUMP FROM 340 TO 334 000 AND BECAUSE IT WAS REALLY WEIRD
I SCATTERED WORKING ON SPACE SHOOTER RS MADE WITH THE AMETHYST
I SEE A LOT OF CLAPPING HANDS IN THE CHAT RIGHT NOW
I SEE A QUESTION HAPPENING
I SEE ALREADY MATTHIJS YOU'RE IN THE CHAT AS WELL
I SEE MYSELF USING THEM ALL IN THE FUTURE
I SEE THE QUESTION
I SHOULD SAY THEY
I STARTED LEARNING ABOUT A COMMON GAME DEVELOPMENT ARCHITECTURE CALLED ECS AND HOW IT WAS USED BY AMETHYST
I STARTED LEARNING ABOUT GAME DEVELOPMENT USING THE AMETHYST GAME ENGINE
I STILL FIND THE OLD O'REILLY BOOK QUITE NICE
I SUPPOSE ONE OF ITS KILLER FEATURES
I TALK TO A LOT OF PEOPLE WHO
I TEACH COMPUTER SCIENCE FOR MY DAY JOB OVER ZOOM
I THINK
I THINK A COUPLE OF FUN ONES FOR YOU FIRST
I THINK HAVING THIS STANDARDIZED TOOL MADE IT VERY EASY TO AD DOCUMENTATION AND THAT IS WHY WE SEE A LOT MORE DOCS IN THE RUST ECOSYSTEM
I THINK I MADE PULL REQUESTS AFTER A WEEK
I THINK I NEED MULTITHREADING AND MAYBE A LIBRARY
I THINK I'VE RANKED THESE IN THE A TIER IN MY TIER LIST
I THINK IT'S ABOUT SOLID LINES OF RUST CODE
I THINK IT'S THE SUM TOTAL OF THESE FEATURES WHICH IS IMPORTANT
I THINK MAYBE WHERE IT WOULD BE A BETTER OR MORE HELPFUL WOULD ACTUALLY BE TO DEVOTE MORE TIME AND ATTENTION TO IMPROVING ERROR MESSAGES IN LIBRARIES
I THINK ON OTHER EMBEDDED DEVICES IT PROBABLY IS MORE
I THINK PEOPLE ARE VERY FASCINATED BY THE TOPIC OF EMBEDDED AND ROBOTS SO PLEASE LIKE I SAW HOW EXCITED YOU ARE FOR IT
I THINK SO
I THINK SOME OF YOU MIGHT DISAGREE
I THINK TECHNOLOGY TAKES A LITTLE BIT OF A BACKSEAT
I THINK THAT IT IS WELL WORTH THE EFFORT TO MAKE OUR DOCUMENTATION INTERACTIVE BECAUSE IT WILL HELP US TO BRING MORE PEOPLE INTO RUST AND PART OF THE REASON WHY JAVASCRIPT IS SO POPULAR IS THAT IT IS SO EASY TO USE IT AND ACCESS IT
I THINK THAT'S A GOOD PLAN
I THINK THAT'S PROBABLY IN AS GOOD A SPOT AS IT'S GOING TO GET
I THINK THAT'S PROBABLY THE BEST YOU CAN DO THERE
I THINK THAT'S THE BEST WAY TO BE PORTABLE BECAUSE IT ALLOWS MANY DIFFERENT SITUATIONS TO MAKE USE OF YOUR LIBRARY
I THINK THERE ARE DEFINITELY A LOT OF ALTERNATIVES HERE
I THINK THIS WOULD BE BEST USED ALONGSIDE THE THREAD LESSONS
I THINK WE ARE RUNNING OUT OF TIME
I THINK WE AS SOFTWARE DEVELOPERS ARCHITECTS WE ALWAYS LIKE TO� NOT TO BE HONEST TO FEEL CLEVER
I THINK WE COULD MAYBE HAVE TO CONSIDER LIKE HOW WE CAN CONVERT FROM NETWORK PACKET REPRESENTATION TO DIFFERENT CODES DIFFERENT TYPES FEATURED IN THE OUTPUT CODE BUT THAT'S RELATIVELY STRAIGHTFORWARD I THINK
I THINK WE HAVE REACHED THE END
I THINK WE'RE OUT OF QUESTIONS
I THINK WHEN YOU HAVE A SKIN IN THE PROJECT
I THINK WITH A SIMPLE CRATE THAT LOOKS LIKE THIS
I THOUGHT IT WAS UNSOPHISTICATED NOT WORTH SHARING SO IT JUST KIND OF COLLECTED VIRTUAL DUST IN MY HARD DRIVE UNTIL THIS SUMMER OF 2020 WHEN THANKS TO COVID THERE WAS A LOT OF FREE TIME AND I WENT THROUGH MY OLD HARD DRIVE AND REDISCOVERED IT
I TWEAKED THIS APPROACH AND ENDED UP CLOSER TO
I UNDERSTAND HOW IMPORTANT ACTUALLY SERIALIZATION SHOULD BE IN PROGRAMMING
I USE A LOT OF ANALOGIES WHEN LEARNING NEW CONCEPTS SO I LIKE TO THINK OF THESE BASIC TYPES LIKE LEGO BRICKS
I USE GRAPHQL AND WE ARE ALL ON THE SAME TEAM
I USED AN ENUM TO DEFINE A LIST WHICH NOW WORKS AS A
I USED THE AVR HAL AND I GOT A LOT OF HELP
I USUALLY GO
I WANT I DECIDED TO MAKE A GAME
I WANT TIERED C COMPILATION
I WANT TO AVOID TEACHING SOME OUT OF SCOPE TOPICS
I WANT TO BUY COMPONENTS
I WANT TO ENABLE STUDENTS WITH RUST'S POWERFUL TOOLING AND ECOSYSTEM
I WANT TO OFFER A VARIANT WHERE I DON'T TAKE A DIFFERENT STANDARD LIBRARY
I WANT TO OFFER VARIANT OF MY LIBRARY WHERE I AM NOT TAKING A DEPENDENCY
I WANT TO POINT SOME RELATIONAL ALGEBRA CAN BE OPTIMIZED BY A COMPILER THAT LOADS THIS IN HIR
I WANT TO POINT YOU IN SOME DIRECTION WHERE WE ARE MOVING
I WANT TO SEE
I WANT TO SORT OF PREFACE THIS BY SAYING THAT MORE THAN ONE FEATURE
I WANT TO THANK MY MENTOR AND AVH HAL
I WANT TO THANK YOU BOTH SO MUCH FOR YOUR TIME AND INTERESTING PRESENTATION AND PLEASE DO CHECK OUT THE CHAT
I WANT TO WRITE THE FASTEST CODE AS I CAN WITH AS FEW BUGS AS POSSIBLE
I WANTED TO INCORPORATE THE SAME KIND OF WISDOM IN THE WAY MY ALGORITHM WOULD DO THE SEARCH
I WAS AWARE THAT REFACTORING WAS NEEDED BUT WASN'T SURE WHERE TO START
I WAS GETTING TIMES THAT WERE 10 TIMES AS FAST AS CAIRO WHICH IS A SINGLE THREADED CPU RENDERER
I WAS GREATLY INSPIRED IN FINE ART CLASSES ESPECIALLY WHEN DOING OIL STILL LIVES WE WERE NEVER TAUGHT TO SOLVE THE DETAIL FREQUENCIES IS AT ONCE
I WAS INTERESTED IN COLLABORATING BECAUSE I WANTED TO EXPAND MY KNOWLEDGE BY WORKING ON AN EXISTING GAME
I WAS JUST KIND OF LIKE THAT OVERWHELMED BY EVERY TIME I SAW AN ERROR MESSAGE
I WAS ON THE SAFER PROTOCOL DEVELOPMENT PROJECT
I WAS SO EXCITED
I WAS THINKING OF SOME NAMES AND I'M TOTALLY BLANKING
I WAS USING BRANCH REQUESTS BUT NOT TO THE EXTENT THAT I NEED BE
I WILL NOW TELL YOU ABOUT THE SERVO MOTORS BUT ALSO THE TIMERS WHICH ARE VERY IMPORTANT IN THIS KIND OF PROJECT
I WILL OF COURSE SHOW YOU WHAT I MEAN WITH AN ANIMATION AT THE END OF THE SLIDE
I WILL SEE YOU LATER
I WILL SHOW YOU HOW I APPROACHED IT FROM MY ART EDUCATION AND INCORPORATING IT INTO THE SEARCH
I WILL SHOW YOU THE ROBOT AND THEN EXPLAIN EVERYTHING YOU NEED TO KNOW ABOUT EVERY PART OF THE CODE AND SHARE A LOT OF MISTAKES I'VE MADE AND THEN THERE WILL BE A LITTLE SURPRISE
I WILL TALK ABOUT THIS TODAY
I WON'T GO INTO WHY THAT IS AT THIS MOMENT BUT IT'S IMPORTANT TO KNOW THAT THEY DON'T ALWAYS WORK
I WORK ON GOLANG IN MY CURRENT JOB
I WORK ON THE ATTINYS WHICH ARE EXTREMELY LIMITED AND YOU
I WOULD GO SO FAR AS TO SAY MANY OF US CODE IN A CULTURE THAT IS HOSTILE TO HIGH PERFORMANCE PROGRAMMING METHODS AND THIS IS TRUE WHEN THOSE GAINS COME WITH ANY ENGINEERING COST
I WOULD LIKE TO DRIVE THESE POINTS HOME WITH A SERIES OF CASE STUDIES
I WOULD LIKE TO POINT OUT THAT ABSTRACTIONS CANNOT BE IMPLEMENTED WITHOUT THE USE OF SERIALIZATION
I WOULD LIKE TO THANK YOU FOR LISTENING
I WOULD NOT NECESSARILY GO THERE AT THE BEGINNING
I WOULD RECOMMEND WATCHING DATA ORIENTED PROGRAMMING BY MIKE ACTON
I WOULD SAY I THINK AT THIS POINT WITH KIND OF THE FORMAT THAT IT HAS
I WOULD SAY THEY ALSO HAVE KIND OF EMBRACED THIS
I WOULD THINK SO
I WOULD THINK THE CURRENT WAY IT'S DONE RIGHT NOW WITH CLIPPY IS PROBABLY WHAT ADHERES TO THAT PHILOSOPHY THE BEST IN THIS CASE
I WOULDN'T EVER CALL JSON A COMPRESSION FORMAT BUT IN PRINCIPLE THE BUILDING BLOCKS OF LOSS LESS COMPRESSION WITH THERE
I WRITE ABOUT IT ON BLOG POSTS
I'M A FREELANCE SOFTWARE DEVELOPER I'M A BIG FAN OF RUST
I'M A PHD STUDENT
I'M A READER
I'M A SECOND YEAR PHD AT GLASGOW UNIVERSITY STUDYING NETWORK SECURITY
I'M A WELDER PURSUING AWS CERTIFICATION
I'M ADDING CODE THAT DOESN'T GET CALLED AND THAT CHANGES THE OBSERVABLE BEHAVIOR OF THE PROGRAM
I'M ALL SWEATY AND HAPPY
I'M ALSO A CONTRACT SOFTWARE DEVELOPER FOR A COMPANY CALLED MEVEX WHICH IS A CANADIAN LINEAR ACCELERATOR MANUFACTURER
I'M ALSO AS I MENTIONED PREVIOUSLY USING STATIC MUT
I'M CHRISTIAN POVEDA
I'M COLOMBIAN
I'M GAVIN MENDEL GLEASON THE CTO FOR TERMINUSDB AND I WANTED TO TALK A LITTLE BIT TODAY ABOUT RUST AS A FOUNDATION IN A POLYGLOT ENVIRONMENT
I'M GOING TO BE BASING THIS COURSE ON FUNDAMENTALS OF COMPUTER SCIENCE II
I'M GOING TO BREEZE THROUGH
I'M GOING TO REMOVE REFERENCES TO THE CORE LIBRARY WHERE POSSIBLE
I'M HERE WITH DIANE HOSFELT AND WE WILL BE TALKING ABOUT SECRET TYPES IN RUST
I'M LIVING HERE IN MUNICH WE HAVE QUITE A LOT OF MOUNTAINS
I'M LOOKING FORWARD FOR THE REST OF THE TALKS
I'M LOOKING FORWARD TO A STABLE BOX WITH CUSTOMER ALLOCATABLE SUPPORT
I'M NOT SURE I WOULD HAVE WRITTEN OCHRE WITHOUT PATHFINDER I HAVE TO GIVE BIG ACKNOWLEDGMENTS TO PATRICK FOR THAT
I'M NOT SURE WHY IT MAKES SENSE THAT MUTABILITY IS CHECKED WHEN IT'S CHECKING THE BORROW CHECKING RULES BUT THAT'S HOW IT WORKS
I'M PRETTY SURE YOU HAVE YOUR OWN IDEAS AND OBJECTIVES YOU HAVE YOUR OWN CRAZY STUFF THAT YOU WANT TO IMPLEMENT TALKING ROBOTS SO I DON'T KNOW
I'M REALLY LOOKING FORWARD TO ITS DEVELOPMENT SO PLEASE GO AND CONTRIBUTE SO I CAN DO THE PAINTINGS ON THE GPU
I'M RUNNING IT ON MY REGULAR LINUX TARGET AND IT IS WORKING
I'M TEMPTED TO SAY YES YES YOU COULD
I'M VERY GRATEFUL THAT THE RUST EMBEDDED COMMUNITY IS WORKING SO HARD ON MAKING RUST
I'VE BROUGHT MY ROBOT SKULL
I'VE DONE A LITTLE BIT WITH RUST
I'VE DONE LIKE A GAME JAM IN THE PAST
I'VE HEARD OF THERE BEING COMPILER BUGS RELATED TO INLINING
I'VE MESSED AROUND A LITTLE BIT WITH THE OTHER EMBEDDED TARGETS
I'VE REALLY FOUND IT A GOOD MIDDLE POINT IS WELL EXAMPLE SOURCE CODE FROM BOOKS
I'VE TRIED A FEW SMALLER GAMES
IDEALLY THE RUST COMPILER SHOULD TAKE CARE OF THIS FOR US BUT FOR NOW TO MAKE IT WORK IN THE GENERAL CASE WE WILL NEED TO FIND A WAY TO AUTOMATICALLY LINK RUST DEPENDENCIES WHICH ARE COMPILED AS WEBASSEMBLY MODULES
IDEALLY THESE DISCUSSIONS WOULD INVOLVE ANY PRE IMPLEMENTATION WORK SUCH AS CLARIFYING THE PROBLEM BEFORE WRITING ANY CODE
IF A PROJECT IS A LIBRARY YOU WILL NOT SET THIS AND THERE IS NO IMAGE BECAUSE YOU ARE NOT ABLE TO RUN THE LIBRARY ON ITSELF
IF ANY
IF ANYONE HAS ANOTHER QUESTION IN THE CHAT YOU CAN ANSWER ALL THE QUESTIONS
IF ANYTHING OF THIS CAUGHT YOUR ATTENTION I ENCOURAGE YOU TO CONTRIBUTE TO MIRI FOR MANY REASONS
IF I HID THE VALUES OF ANY PROCEEDING BYTES IN THE DOCUMENT IT WOULD BE IMPOSSIBLE TO TELL
IF I WANT TO RUN IT IN ANYTHING ELSE I CAN DO IT
IF IT IS NOT A TEST IT IS NOT COMPILED
IF IT IS NOT PRESENT IT EXPANDS IT INTO CARGO EXPAND MEANING CARGO IS EXPANDABLE ON IT'S OWN
IF IT WAS AN ERROR WE RETURNED THE ERROR
IF IT'S NOT A POP THEN WE WILL BREAK OUT OF OUR LOOP
IF NOT BAD THINGS WILL HAPPEN AND BAD THINGS ALSO CALLED UNDEFINED BEHAVIOUR SO IF YOU'RE HERE AND NOTHING IS WORKING AND YOU'RE GETTING FRUSTRATED JUST CHECK IF EVERYTHING HAS A COMMON GROUND
IF NOT CORRECTLY YOU MAY HARM PERFORMANCE
IF NOT IF WE HAVE DETECTED SOMETHING WE JUST WRITE ZERO TO THE TIMER REGISTER AND THEN WE MONITOR HOW LONG THE ECHO IS HIGH
IF NOTHING WORKING AND YOUR CALCULATIONS ARE WRONG IT MIGHT BE THE CAUSE
IF OUR PIN CHANGES VALUE IT WILL JUMP INTO OUR INTERRUPT
IF PEOPLE WANT TO TALK HOW TO OPTIMISE THAT MAKE IT CLEANER OR MORE IMPROVEMENTS THAT WOULD BE GREAT
IF PERMITTED BY YOUR JURISDICTION
IF SCIENCE HELPS US TO REASON ABOUT THE EXTERNAL WORLD AND DECONSTRUCT A PROBLEM INTO PROCESSING FLOW I THINK ART IS ABOUT LOOKING INWARD
IF SOMEBODY WANTED TO TRY THAT OUT IT'S LIKE I MESSED UP HERE THERE AND YOU KNOW
IF SOMETHING GOES BAD IT CAN BE FIXED IN LATER STAGES GIVING A CONCEPTION OF CONTINUOUS PROBLEM SOLVING IN THE BRUSH LAYOUT ITSELF
IF THAT DOESN'T HAPPEN MIRI WON'T BE OF USE IN THIS CASE
IF THE COMPILER IS TRUSTING THAT TO HAPPEN AND YOU'RE BREAKING THAT RULE THEN YOU'RE CAUSING UNDEFINED BEHAVIOUR
IF THE CONDITIONAL VALUE WAS FALSE IT WILL BE A MASK OF ONLY ZEROS
IF THE GAME STARTS WITH A MOVE X COORDINATE 4 AND Y COORDINATE 4 THERE WOULD BE A DOT WITH HIGH 4 FOLLOWED BY A DOT WITH HEIGHT 3 AND SO ON
IF THE INDEX YOU'RE READING IS OUT OF BOUNDS FROM THE LENGTH OF THIS ARRAY THEN WE WOULD RETURN NONE AND IF WE ARE SURE THAT WE ARE IN BOUNDS THEN WE RETURN SOME AND THEN DO A GET UNCHECKED FUNCTION
IF THE OP CODE IF THE INSTRUCTION IS A POP THEN IF THE CURRENT INSTRUCTION IS A POP THEN WE CONTINUE
IF THE PREDICTION IS WRONG YOU HAVE TO PAY MORE BITS
IF THE SERIALIZATION FORMAT HAS LOW ENTROPY THE THROUGHPUT OF DATA FLOWING THROUGH THE SYSTEM IS LIMITED BY THE WIRES CONNECTING COMPONENTS
IF THERE ARE ERRORS THE RUST COMPILER WILL ALERT US TO THIS
IF THERE IS INTERESTING FOR A WORKING GROUP THEN YES SOMEONE WILL HOP ON FROM THE AUDIENCE
IF THERE WERE ANY QUESTIONS I WOULD BE HAPPY TO ANSWER
IF THERE WERE ONE AREA OF IMPROVEMENT WHEN IT COMES TO COMPILER DIAGNOSTICS IN RUST WHAT WOULD THAT BE
IF THERE'S A NEW COMPONENT AND YOU'RE SORT OF LOOKING FOR AN ALTERNATIVE LANGUAGE I THINK RUST IS A REALLY GOOD CHOICE FOR THIS
IF THERE'S A POTENTIALLY MEMORY UNSAFE OPERATION GOING ON
IF THIS WERE A PHYSICAL CONFERENCE WE WOULD PROBABLY MEET JEFFREY WHO WROTE THE THING
IF WE ARE USING SAFE RUST IF WE PROMISE NEVER EVER EVER TO USE UNSAFE WE DON'T HAVE TO WORRY ABOUT UNDEFINED BEHAVIOURS BECAUSE UNDEFINED BEHAVIOURS SHOULD NOT HAPPEN IN SAFE RUST
IF WE BREAK ANY OF THESE RULES WE SAY WE ARE CALLING UNDEFINED BEHAVIOUR
IF WE CAN SUCCESSFULLY PARSE THIS AND WE CAN SUCCESSFULLY USE IT FOR TESTING THEN WE THINK THAT'S QUITE A GOOD PROMOTION I SUPPOSE
IF WE CAN TALK MORE
IF WE CAN'T UNWIND A PANIC THEN A PANIC OCCURS WE HAVE A LOT FEWER CLUES ABOUT WHAT IS CAUSED THE PANIC TO HAPPEN
IF WE COULD DO THAT THEN THE DELTA COMPRESSION METHOD WOULD DOMINATE GZIP AND THAT IS THE ASPIRATION OF TREE BUF
IF WE DID USE THE FULL RANGE THE ENCODING WOULD HAVE TO HAVE SOME VALUES EXTEND BEYOND EIGHT BITS BUT INDEED MOST DATASETS DON'T USE THE FULL RANGE
IF WE DO NEED TO RESTORE THE FRAME POINTER THE CODE DOESN'T WORK
IF WE EXPLICITLY PANIC RATHER THAN PANICKING WHEN WE UNWRAP AN ERROR CASE THEN IT WORKS
IF WE FORGET ABOUT THE DETAILS AND LOOK AT THE DELTA COMPRESSION METHODS UNDERLYING PRINCIPLES WE FIND THE ESSENCE OF TREE BUF
IF WE GO BACK TO THE CODE HERE YOU SEE THAT I JUST HAVE A MUTABLE DELAY TO MAKE THE ROTATION NOT TOO FAST AND THEN WE JUST SET THE DUTY TO 24 SORRY TO 16 WE WAIT A BIT AND WE CENTRE IT AGAIN AND THEN WE WAIT A BIT 400 MILLISECONDS AND THEN WE PUT IT TO THE LEFT AND I'M GOING TO SHOW HOW IT LOOKS LIKE
IF WE GRAPHED THE DATA DEPENDENCIES OF A JSON DOCUMENT IT WOULD FORM A CONTINUOUS TRAIN STARTING WITH THE SECOND BYTE AND THE FIRST DEPENDING ON THE FIRST AND THE THIRD DEPENDING ON THE PREVIOUS TWO CONTINUING UNTIL THE VERY LAST BYTE OF THAT DOCUMENT
IF WE HAD ANY QUESTIONS OR IDEAS ABOUT AN ISSUE WE WERE WORKING ON WE WOULD POST THEM TO THE ISSUE THEY WERE RELEVANT TO
IF WE JUST TAKE A STROLL AND AIMLESSLY WANDER AROUND IN THE SPACE WE MIGHT DISCOVER THAT WITH JUST 100 BRUSHSTROKES WE CAN DEPICT A LOT OF INTERESTING STUFF BUT ALSO A LOT OF RANDOM STUFF
IF WE LOOK AT THE SPACESHIP AND ENEMY ENTITIES THEY HAVE A NUMBER OF SIMILAR BEHAVIORS MOTION ANIMATION AND HEALTH
IF WE NEEDED TO ACCESS A HEALTH COMPONENT FOR THE PLAYER ENTITY WE NEED AN EXPRESSIVE WAY TO DO THIS
IF WE START TO INCLUDE DEPENDENCIES IN OUR SMALL CODE SNIPPETS THE COMPILATION WILL TAKE A LARGE AMOUNT OF TIME AND RESOURCES AND THE RESULTING MODULE WILL HAVE A HUGE SITE EASILY TAKING UP SEVERAL MEGABYTES MAKING IT HARDER TO SCALE
IF WE TREAT EACH STEP WITH ITS OWN FUNCTION CALL WE CAN DO AN INTERESTING THING HERE
IF WE WANT TO
IF WE WANT TO IMPLY THE SINGLETON LIKE IN JAVA OR C PLUS PLUS WE MAY NEED LAZY LOCK WHICH IN FACT CAN BE AVOIDED IF WE CAN HAVE A MEMORY MODEL TO ESTABLISH THIS BEFORE THE RELATIONSHIP BETWEEN THE CHANGE AND THE BETWEEN THE WRITE AND THE READ
IF WE WANT TO PROVIDE SOME NUMBERS FOR THE PROCESSER TO WORK ON WE NEED TO GO TO OUR TABLE AND PICK UP AN ETCH A SKETCH AND IDEALLY FIND A BLANK ONE
IF WE WANTED TO WRITE AN ALGORITHM TO PREDICT WHAT WOULD COME NEXT IN THE SEQUENCE THE ALGORITHM COULD BE MINIMAL
IF WE WERE ASKED TO REPRESENT THE SHEEP IN CODE WE MIGHT ADOPT AN INHERITANCE PATTERN OF THINKING AND INHERIT IT FROM AN ANIMAL CLASS OR MIGHT SAY THAT ANIMAL IS JUST ONE OF THE TRAITS AND THERE ARE OTHER TRAITS WE ARE INTERESTED IN SUCH AS ADORABLE OR FLUFFY
IF WE WERE GOING TO EXTEND FROM JUST THE X AND Y CORD TO A WHOLE TERM INNOCENT IT MIGHT LOOK LIKE THIS
IF WE WERE IN A REGULAR FUNCTION THIS PROLOG WOULD START WITH LINE 7
IF WE WERE TO ASSIGN A SCORE OF PLUS 1 FOR BEING THE BEST AT SOMETHING AND MINUS 1 FOR BEING THE WORSE DELTA COMPRESSION WOULD COME OUT ON TOP WITH A SCORE OF 1
IF WE WERE TO GRAPH THE BUFFER VERTEX DEPENDENCY THE INTERPRETATION OF EACH BYTE IN THE DATA IS ONLY DEPENDENT ON THE FIRST FEW BYTES IN THE DESCRIPTION OF THERE BUFFER
IF WE WERE TO LOOK AT WHAT THE TRANSFORM STEPS ENTAILS WE WOULD SEE IT BREAKS DOWN FURTHER INTO A SERIES OF PARSE TRANSFORM AND SERIALIZED STEPS
IF WE'RE NOT CAUSING UNDESIRABLE BEHAVIOUR OURSELVES SOMEONE ELSE IN ONE OF OUR DEPENDENCIES MIGHT BE DOING
IF YOU ALWAYS WORK WITH THE MOST DIFFICULT THING THAT YOU CAN POSSIBLY GRASP AND THIS IS THE MOST CLEVER CODE YOU CAN POSSIBLY WRITE IT WILL BE QUITE HARD FOR YOU TO DEBUG THIS CODE OR REFACTOR THIS CODE OR EVEN TO COME BACK TO THIS CODE IF YOU FOR EXAMPLE MOVE TO SOMETHING ELSE FOR A COUPLE OF MONTHS
IF YOU ARE INTERESTED IN LEARNING ABOUT THAT THERE
IF YOU ARE THINKING WHOA
IF YOU CALL OPEN64 MEANING IT WILL BE SOMEONE CALLING OPEN64 THAT'S A FOREIGN FUNCTION THAT I DON'T KNOW THAT'S NOT A RUST FUNCTION AND THEN CONTRIBUTORS CAN WRITE WHATEVER CODE THEY WANT TO EMULATE THAT FUNCTION
IF YOU COULD ACCURATELY PREDICT THE CONTEXT OF EVERY BYTE IN A FILE YOU COULD COMPRESS THAT FILE TO 0 BYTES
IF YOU DO GET STUCK WHAT PLACE DO YOU TURN FOR HELP
IF YOU DO THE RELEASE THEY ARE PRESENT IN THE FOLDERS
IF YOU FIND A STRING IN THE GRAPHQL IT MAY NEST FURTHER
IF YOU FOLLOW THAT THROUGH ALL OF THE MOVES OF THE GAMES AND THE COORDINATES DOWN TO THE BOTTOM ROW THERE IS AN X AND Y PROPERTY WHICH ARE BUFFERERS HOLDING ALL OF THE GAMES AND ANOTHER BUFFER CONTAINING ALL THE Y BUFFERS OF ALL THE GAMES IN THE TOURNAMENT
IF YOU GOOGLE SMART CAR YOU WILL SEE A BUNCH OF SUPPLIERS THAT YOU CAN CHOOSE
IF YOU HAVE A ROMANTIC NIGHT WITH YOUR PARTNER YOU NEED TO CONTROL THE LIGHT RIGHT
IF YOU HAVE AN IMAGE ADJACENT PIXELS ARE LIKELY TO BE THE SAME AND MOST OF THE IMAGES ARE NOT FAR OFF FROM THE COLOR PALETTE
IF YOU HAVE ANY CONST ITEM IN YOUR PROGRAM YOU HAVE A CONSTANT YOU HAVE A CONST FUNCTION PART OF THE MIRI CODE IS USED TO RUN
IF YOU HAVE ANY QUESTIONS FEEL FREE TO ASK US
IF YOU HAVE ANY QUESTIONS PLEASE LEAVE COMMENTS TO THE CHAT
IF YOU HAVE FOLLOWED SO FAR IN UNDERSTANDING HOW THE DELTA COMPRESSION METHOD WORKS YOU ARE ALREADY ALMOST THERE IN UNDERSTANDING TREE BUF
IF YOU HAVE HAD DRAWING CLASSES YOU PROBABLY RECOGNISE THIS
IF YOU HAVE PICKED THE GPU API YOU HAVE TO LOOK AT WHICH YOU ARE WILLING TO TARGET AND WHICH USERS YOU ARE GOING TO EXCLUDE FROM YOUR APPLICATION
IF YOU HAVE SEEN SOME SEQUENCE OF BYTES YOU ARE LIKELY TO FIND THEM LATER
IF YOU HAVE TO SPEND LESS TIME THINKING ABOUT DECIPHERING MESSAGES THAT'S MORE TIME YOU CAN WORK ON THE CODE YOU ARE WRITING
IF YOU HIT CONTROL AND SAVE IN A TOP PERFORMANCE OLAP IS FIRSTLY ACHIEVED WITH ENGINEERING RUST AND ALL SHOWN CAN BE PICKED UP FROM THE OPEN SOURCE TENSORBASE IO
IF YOU IF YOU WANT TO DO SERVER TO SERVER COMMUNICATION FOR THINGS WHICH DO NOT CONTAIN ARRAYS MAYBE SOMETHING LIKE PROTOBUFF WOULD BE BETTER FOR THAT
IF YOU JUST COPY PASTE THE DECLARATION OF A SERIAL IT'S GOING TO WORK
IF YOU JUST GOOGLE ASSEMBLY INSTRUCTIONS SMART CAR ARDUINO YOU WILL HAVE A LOT OF GOOD VIDEOS AND I LINK THEM IN MY REPOSITORY
IF YOU LIKE
IF YOU LIKE THIS IF YOU THINK THIS IS INTERESTING FOR YOU I CAN GIVE YOU SOME IDEAS AT THE END ON HOW CAN YOU HELP CONTRIBUTE IN ALL OF THIS
IF YOU LOOK INTO ANY OF THESE SUB SYSTEMS RAM CPU GPU NETWORK CARD YOU WILL FIND THE EXACT SAME SETUP
IF YOU RUN THIS WITH MIRI YOU WILL FIND THIS SUPER COOL ERROR THAT SAYS UNDEFINED BEHAVIOUR
IF YOU STARE AT THIS CODE HARD ENOUGH YOU MIGHT REALIZE OH WE NEED A TURBOFISH
IF YOU START A PROJECT AND THEY START THROWING ABOUT YOU HAVE TO WORK WITH THIS PARTICULAR TRAIT OR YOU HAVE
IF YOU TRY TO RUN THIS WITH MIRI WE WILL GET AN ERROR BUT IT'S NOT BECAUSE WE ARE CAUSING UNDEFINED BEHAVIOUR
IF YOU TURN THE BATTERY ON FIRST BECAUSE THEN THE DEMO THE DEMO IS NOT GOING TO WORK
IF YOU USE THE PROPER TOOLS TO PARSE AND MANIPULATE THE DATA YOU WILL BE SURPRISED BY THE IMPACT
IF YOU WANT DIFFERENT CAPABILITIES YOU NEED TO CHANGE THE REPRESENTATION
IF YOU WANT SOME SPECIFICS FOR WINDOWS MANY OF THE CHAINS HAVEN'T BEEN IMPLEMENTED YET AND THAT IS FINE BECAUSE YOU CAN CROSS INTERPRET LIKE YOU WERE IN WINDOWS IN LINUX SORRY
IF YOU WANT TO ASSEMBLE IT'S THE SAME
IF YOU WANT TO BREAK UP DATA INTO BATCHES FOR PARALLELISM THE MOST STRAIGHTFORWARD WAY TO DO THAT IS TO HAVE FIXED SIZE STRUCTS IN CONTIGOUS ARRAYS
IF YOU WANT TO CHANGE SOME OF THE GRAPHQL TEXT YOU CAN DO SO EFFICIENTLY AND SAFELY WITH THIS TYPE ALMOST
IF YOU WANT TO DO THE SAME YOU CAN ENABLE DEBUGGING IN THE CARGO AND YOU WILL GET THE SYMBOLS IN YOUR BINARY AND THEN RUN THAT USING THE GDB COMMAND AND WRAP THAT AND ONCE YOU DO THAT THEN GDB PROVIDES AN INTERFACE TO INTERACT
IF YOU WANT TO FOCUS ON THE PROBLEM AND IF PEOPLE ARE INTERESTED IN THAT KIND OF THING THERE IS OTHER INTERESTING PRESENTATIONS THAT YOU COULD WATCH
IF YOU WANT TO GET LIKE MORE INFORMATION ABOUT THIS METRICS YOU CAN GOOGLE OR USE YOUR FAVOURITE WEB SEARCH ENGINE TO LOOK FOR THIS PAPER ABOUT HOW DO PROGRAMMERS USE UNSAFE RUST
IF YOU WANT TO GET SERIOUS ABOUT COMPRESSION AND SQUEEZE THE FILE DONE FURTHER YOU COULD MAKE AN EVEN BETTER PREDICTION ALGORITHM
IF YOU WANT TO IMPLEMENT THOSE TRAITS LIKE SEND FROM THE STANDARD LIBRARY YOU HAVE TO USE UNSAFE
IF YOU WANT TO MUTATE THE STATICS BECAUSE YOU'RE SURE THAT THE PROGRAM NEEDS SOME SORT OF MUTABLE GLOBAL STATE EVEN THOUGH SOME PEOPLE DON'T LIKE IT YOU CAN USE UNSAFE TO DO THAT
IF YOU WANT TO SEE FROM THE SOURCE OF TENSORBASE
IF YOU WANT TO TAKE A LOOK AT THE MIRI REPOSITORY NOW OR MAYBE LATER THIS IS THE URL
IF YOU WANT TO THE NUMBER TWO WAY IS ARENA ALLOCATOR
IF YOU WANT YOUR APP TO RUN AT A SMOOTH SIXTY FRAMES PER SECOND YOU HAVE TO RENDER A LOT MORE PIXELS EVERY SECOND
IF YOU'RE BOARD YOU CAN WRAP ANY OF THOSE ISSUES
IF YOU'RE BORED AND YOU WANT TO DO SOMETHING INSIDE MIRI WE HAVE A LOT OF ISSUES HERE
IF YOU'RE GOING TO USE A TIMER FOR THE SERVO YOU HAVE TO MAKE SURE YOU'RE USING THE RIGHT PIN
IF YOU'RE INTERESTED IN LEARNING RUST OR WANT TO CONTRIBUTE TO AN OPEN SOURCE GAME THEN WE WOULD BE HAPPY TO HELP
IF YOU'RE ONLY INTERESTED IN THE RUST AND ALGORITHM PARTS GO GET YOURSELF A COFFEE AND COME BACK IN ABOUT TEN MINUTES SINCE WE ARE GOING TO GO THROUGH THE META PART FIRST
IF YOU'RE STRUGGLING WITH A LIBRARY LIKE MY ACCESS FOR EXAMPLE IT'S NOT THAT IT'S RELATED I JUST DIDN'T USE A LIBRARY
IF YOU'RE STRUGGLING WITH CONCEPTS THAT USUALLY POP FROM BOOK TO BOOK AND TRY TO WORK WITH THE SIMPLEST POSSIBLE EXAMPLE THAT I CAN MAKE UP AND WELL PLAY AROUND WITH EITHER RUST PLAYGROUND OR LOCAL CODE AND SEE IF YOU CAN MAKE IT WORK
IF YOU'RE WILLING TO GET
IF YOU'VE NEVER SEEN AN ELM ERROR MESSAGE BEFORE IT IS IN FORMAT PRETTY SIMILAR I WOULD SAY TO RUST'S ERROR MESSAGES
IF YOUR LIBRARY IS USING THE LOG GRID THE MACROS FROM THE LOCK GRID THERE IS NO DEFAULT IMPLEMENTATION LOG IMPLEMENTATION
IF YOUR PROGRAM IS RUNNING REALLY SLOW IN MIRI THAT'S FINE
IMAGINE IT TAKES LESS TIME TO EXECUTE PART OF THE CODE WHEN A BIT IS ZERO THAN WHEN IT DOES WHEN A BIT IS ONE
IMMEDIATELY AFTER THAT WE CAN GENERATE A NOM BASED PARSER FOR THAT TYPE
IMPLEMENTING ALGORITHMS
IMPROVING THE ERROR MESSAGES IN ELM
IN 2019 I WAS HONING RUST SKILLS
IN ADDITION TO THAT BROWSERS ARE ALSO INCREASINGLY TAKING ADVANTAGE OF THE GPU
IN ADDITION TO THE NO STANDARD CONTEXT WE ARE
IN CASE
IN CASE ONE IS INTERESTED IN HOW THE PARALLEL SOBEL IS DONE HERE IS A CODE
IN DEBUGGING FIRST WE WILL TART WITH LOGGING TRACING AND THEN GDB
IN DESIGN WE HAVE CAD THREE D MODEL COMPUTER AIDED DESIGN WHERE THE END PRODUCT IS DESIGNED ON THE COMPUTER USING SIMULATION TOOLS FOR AERO DYNAMIC TESTING AND WHATNOT AS WELL AS SOMETHING WE SOFTWARE DEVELOPERS KNOW AS VERSION CONTROL THE EQUIVALENT OF MAKING SURE THAT VARIOUS ITERATIONS ARE TRACKED AND THE DIFFERENCES CAN BE SEEN
IN EACH EXAMPLE WE WILL ALSO GET TO SEE HOW RUST GIVES YOU BEST IN CLASS TO FOR MANIPULATING DATA ACROSS ANY REPRESENTATION
IN FACT ALL OF THE STATE OF YOUR ENTIRE RETURNING PROGRAM IS STORED IN MEMORY IN A COMPLEX FORMAT COMPRISED OF OTHER NESTED SIMPLER SERIALIZATION FORMATS
IN FACT IT IS NOT A SINGLETON BECAUSE WE NEED LOCK
IN FACT RUST ERASES THE TYPE OF AN OBJECT WHEN YOU UPCAST IT INTO A TRAIT OBJECT
IN FACT THE COMMUNICATOR IS CONTINUING TO IMPROVE THE PROBLEM ON MORE ECOSYSTEM
IN FACT THE PROPORTION OF INTERESTING STUFF TO RANDOM IT INSANELY LOW
IN FACT THEY SHOULD ONLY BE CHECKING EQUALITY BETWEEN TWO OBJECTS WHEN THEY KNOW THOSE GO OBJECTS ARE OF THE SAME TYPE
IN FACT WE HAVE USED THE RASTER PARADIGM IN THE TENSORBASE
IN FUNDIES2 THIS IS DONE WITH JAVA INTERFACES
IN GENERAL PROJECT IDEAS NOT READY FOR THE PUBLIC ARE KEPT IN DIRECT MESSAGE
IN GENERAL THAT IS PRETTY MUCH IT
IN JSON A SMALLER NUMBER TAKES FEWER BYTES TO REPRESENT THAN A LARGER NUMBER
IN MATHEMATICS WE CAN TRANSFORM AND MAP IT INTO A NEW SPACE
IN MOST ASSEMBLY VIDEOS AND ON THE REP ON
IN MY FREE TIME ENJOY TINKERING WITH ELECTRONICS DESIGNING AND PRINTING DID�THREE D PARTS
IN OTHER WORDS WE'RE GOING TO TELL THE MICROCONTROLLER HOW LONG DO WE WANT THE SIGNAL TO BE ACTIVE
IN PARTICULAR A SPRITERENDER COMPONENT CAN TELL AMETHYST WHICH SHOULD BE DRAWN
IN PARTICULAR TAKE A LOOK AT THE MOTION COMPONENT AS ONE OF THE REQUIRED BEHAVIORS FOR THESE TWO
IN PRINCIPLE YES BUT THERE ARE A LOT OF QUESTIONS LIKE
IN PRINCIPLE YES YOU CAN BUILD FOR EXAMPLE A STACK MODEL FOR VMIR BUT THE INFERENCE IS YOU CAN BUILD IT
IN PROGRAMMING WE ARE OFTEN FACED WITH A CHALLENGE OF TRANSLATING THE LANGUAGE OF OUR THOUGHTS INTO THE LANGUAGE OF IMPLEMENTATION
IN PROLOG YOU DON'T HAVE TO WORRY ABOUT GARBAGE COLLECTION OR HOW YOU ALLOCATE THINGS
IN PROLOG YOU WOULD HAVE A RUNNING INSTANCE AND THEN YOU DO LIVE RECOMPILATION OF PARTS OF THAT PROGRAM SO IT IS A VERY SHORT LOOP BETWEEN WRITING YOUR CODE AND SEEING IT IN ACTION
IN RUST IT IS CALLED A DATA FUSION WHICH IS USED APACHE ARROW TO REQUIRE DATA IMAGE
IN RUST IT TOOK A LITTLE BIT LONGER
IN RUST THAT SOMETHING UNLEASHED
IN RUST THERE IS A CRATE CALLED LOG THAT PROVIDES A SIMPLE API WITH MULTIPLE LOG LEVELS THAT YOU CAN USE TO EMIT EVENTS
IN RUST YOU HAVE TWO WAYS OF WRITING TESTS
IN SOME CASES THAT'S OK
IN STAGE 3 WE HAVE THE RESULTS OF MY INTERNSHIP WORK A RUST LIBRARY FILE CONTAINING CORRECT USABLE PARSER FUNCTIONS AUTOMATICALLY GENERATED FROM THE INFORMATION WE HAVE IN STAGE 2
IN SUMMARY THE MAIN TAKEAWAYS ON THE COLLABORATION WE USED WERE ENGAGING REGULARLY IN OPEN DISCUSSION IS BENEFICIAL TO CAPTURING PROJECT PROGRESS
IN THE COURSE STUDENTS ARE TAUGHT THAT DATA IS THE SAME WHEN IT'S REFLEXIVE SYMMETRIC AND TRANSITIVE
IN THE CURRENT VERSION IT'S FASTER THAN WHAT I SHOWED YOU BUT IT'S BECAUSE THEY HAD NO DO LESS CHECKS
IN THE DEPENDENCY SECTION WE CAN SEE WE TAKE A DEPENDENCY ON THE LASER STATIC AND IT IS OPTIONAL
IN THE DEVELOPER FACING PART YOU EDIT THE PACKAGE
IN THE DEVELOPMENT OF THE FRONTEND IT IS PROBABLY MUCH EASIER TO USE REACT THAN TO USE RUST
IN THE DOG CLASS WE HAVE THE SAME ANIMAL METHOD WHICH IS INHERITED FROM THE ANIMAL INTERFACE
IN THE END I MODIFIED THE SEARCH QUITE A BIT WHICH ACTUALLY MADE IT REDUNDANT TO FRAME IT AS A GENETIC ALGORITHM AND I WILL TOUCH UPON IT LATER IN THE PRESENTATION
IN THE END I WENT WITH A CUSTOM IMPLEMENTATION THAT USES CHUNKS TO MAKE IT PARALLEL
IN THE END THESE ARE ALL REPRESENTATIONS
IN THE EPILOGUE WE POP FROM 28 AND 29 AND THEN WE SEND OUT TO OUR FRAME POINTER
IN THE EXAMPLE BASED PLACEMENT YOU CAN SEE OBJECTS MAGICALLY MOVING AROUND UNTIL THEY SETTLE INTO THE POSITIONS THAT SATISFY THE EXAMPLE
IN THE FIRST CASE WHERE WE ANNOTATED THIS IS INCLUDED IN THE FEATURE STD IS ENABLED AND IN THE SECOND CASE NOT
IN THE GO GAME THE SAME COORDINATE ON THE BOARD IS SELDOM REPEATED
IN THE MIR YOU HAVE A LIFETIME FOR EVERY SINGLE VALUE
IN THE NEXT VERSION WE ALSO WANT TO CONTINUE TO SUPERBIN COMPLEX AGGREGATIONS FOR EXAMPLE GROUP BY
IN THE PROGRAMMING CONTEXT EAGERNESS IS SHOWCASED WHEN DIAGNOSTICS ARE CONSTRUCTED IN RUSTC
IN THE PROLOGUE WE PUSH INTO 28 AND 29 AND THEN WE READ INTO OUR
IN THE TENSORBASE WE ARE FORCED TO DECIDE PERFORMANCE IN THE COREMENT WE DO MODERNIZATION
IN THEIR BINARY GRID THEY DEPEND ON THE TRACING CODE PACKAGE AND THE FIRST DISABLE THE DEFAULT FEATURES BECAUSE THEY DON'T WANT TO OPT INTO THE DEFAULT FEATURE AND DISABLE THEM AND ENABLE THE ALLOC FEATURE
IN THESE CODE SNIPPETS SPACESHIP AND ENEMY HAVE DATA REQUIRED FOR THE MOTION BEHAVIOR
IN THIS CASE
IN THIS CASE IT SEEMS THE CONFIG FILE IS CAUSING UNDEFINED BEHAVIOUR
IN THIS CASE THE COMPILER SHOULD GIVE US AN ERROR BECAUSE THAT IS NOT ALLOWED
IN THIS CASE WE ARE CONCERNED ABOUT TIMING SIDE CHAPELS WHICH OCCUR WHEN ATTACKERS ANALYSE THE TAME TAKEN TO EXECUTE A A CRYPTOGRAPHIC ALGORITHM WHICH CAN BE SEEN AS AN IMPLICIT OUTPUT
IN THIS CASE WE CAN OUTPUT THE HTTP REQUEST AND IT IS REALLY HELPFUL TO SEE WHAT KIND OF REQUEST GETS SENT WHEN YOU SEND THIS CODE BECAUSE IT CAN HELP YOU LEARN MORE ABOUT HTTP AND MORE THAN THAT IT CAN ALSO HELP TO YOU DEBUG PROBLEMS BECAUSE WITH AN INTERACTIVE PLAYGROUND LIKE THIS YOU CAN REPLACE THE CODE WITH YOUR OWN CODE AND OBSERVE THE CHANGES AND OBSERVE ITS BEHAVIOUR
IN THIS DIAGRAM WE HAVE AN EXAMPLE OF AN ANIMATION SYSTEM IMPLEMENTED USING THE AMETHYST GAME ENGINE
IN THIS GRAPHIC WE HAVE THREE ROWS OF BOXES WHERE WE WILL DESCRIBE THE VARIABLE LENGTH ENCODING
IN THIS NEXT SEX HOW WE COLLABORATED TOGETHER TO IMPLEMENT THE REFACTORS WE DISCUSSED PREVIOUSLY
IN THIS SECTION OUR TALK WE'RE GOING TO PROVIDE SOME BACKGROUND FOR THE SPACE SHOOTER GAME
IN THIS STAGE IT IS WHERE THE PROCESS HAPPENS THE TYPING HAPPENS SO A LOT OF TYPES ARE HERE AT THIS STAGE
INCLUDES HOW MANY ITEMS CHARACTERS BOSSES AND LEVELS YOU WANT IN THE GAME
INCLUDING AS YOU CAN SEE SEVERAL THAT RELATE TO AVR INTERRUPTS
INCLUDING TASKS UPDATING THE README BE AN ENTRY POINT
INEFFICIENT CODE IS OKAY
INPUT IS JUST PLAIN SQL IN A PARSE TREE
INSIDE UNSAFE FUNCTIONS OR UNSAFE BLOCKS WHEN YOU HAVE THE TWO THERE'S NOT MUCH YOU CAN DO ACTUALLY
INSIDE WE ARE NOT UPDATING THE VARIABLE
INSTEAD OF WRITING AN X FOLLOWED BY A Y LIKE MOST SERIALIZATION FORMATS WOULD DO LET'S WRITE OUT ALL OF THE XS FIRST AND THEN ALL OF THE YS
INSTRUCTIONS ARE SERIALIZED CODE COMING FROM THE ASSEMBLY COMING FROM SERIALIZED MIRROR COMING FROM SERIALIZED RUST SOURCE FILES COMING FROM SERIALIZED KEYBOARD PRESSES AND SO ON
INSTRUCTORS DON'T INTRODUCE NULL YET SO I'M NOT REALLY WORRIED ABOUT THAT FOR NOW
INSTRUCTORS TEACH STUDENTS HOW TO THROW EXCEPTIONS WHEN TO THROW EXCEPTIONS WHICH EXCEPTIONS TO USE AND HOW TO CATCH THE EXCEPTIONS
INTEGERS BETWEEN 0 9 TAKE ONE BYTE BECAUSE THEY ONLY NEED A SINGLE CHARACTER
INTERESTING
INTERPRETING BYTES AS ANOTHER TYPE LIKE A STRING OR INTEGER IS ALSO IMPORTANT
INTO ONE TALK TO MAKE
INTO RUST AND�LLVM THANKS TO A SIGNIFICANT AMOUNT OF EFFORT BY A GENTLEMAN DYLAN MCKAY
INTRODUCTORY COMPUTER SCIENCE COURSE WRITTEN
IRONICALLY I DON'T WORK PARTICULARLY WELL WITH VIDEOS
IRONICALLY THE STRING VARIANT IS NOT
IS A FORUM CALLED AVR FREAKS
IS A REALLY BIG DEAL
IS IT HARD TO START OFF WITH SOMETHING THAT IS EMBEDDED AND WHAT YOUR NEXT PLANNED ROBOT IS
IS MORE OF AN OPERATIONAL MODEL
IS THERE ANYTHING TREE BUF IS BAD FOR
IS THERE ANYTHING YOU WOULD LIKE TO SHOW OFF LIKE A FINAL USE CASE OR AN IDEA HEY IF SOMEONE IS BORED MAYBE GIVE A SHOT AT THIS PROJECT
IS THIS A RESULT OF CULTURE WITHIN THOSE ECOSYSTEMS
IS THIS LIKE
IS YOU'RE NOT PROGRAMMING ALL THE BOARD BUT YOU ARE PROGRAMMING THE MICROCONTROLLER
IT ABSTRACTS OVER THE ACTUAL LOGGING IMPLEMENTATION
IT ACTUALLY RETURNS ZERO
IT ACTUALLY TRIES TO PARSE THAT AS A VALID STATEMENT
IT ALLOWS YOU TO BE EVEN BORED WITH WHAT YOU'RE WORKING ON
IT ALLOWS YOU TO HAVE RUN TIME CAPABILITIES ON WHAT IS HAPPENING IN THE RUN TIME
IT ALLOWS YOU TO RETRIEVE INFORMATION
IT ALSO BRINGS US THE METAL FACTORY EQUIPMENT THAT BOTTLES OUR BELOVED COCA COLA DRINKS AND THE BELT CONVEYER THAT RUN THE AMAZON WAREHOUSES THAT BRING THE BOXES TO OUR FRONT DOORS
IT ALSO HAS THE FUTURE ADVANTAGE OF GIVING STUDENTS A BETTER UNDERSTANDING OF THE MONADIC STYLE OF RUST
IT ASSUMES WHATEVER IS AFTER THE TWO COLONS OF THE
IT BASICALLY TRIES TO
IT BECOMES MESSIER TO VISUALISE
IT CAME FROM INSPIRATION FROM OTHER GAMES
IT CAN BE A GENETIC ALGORITHM GRADIENT DESCENT SIMULATED ANNEALING
IT CAN BE COMPARED TO HOW YOU WORK WITH THE DEBUGGER WHICH CAN GO THROUGH A PROGRAM STEP BY STEP AND WHILE IT GOES THROUGH THE PROGRAM IN THIS FASHION IT ALSO CAN SHOW THE INTERNAL STATE OF THE PROGRAM AT THIS PARTICULAR POINT IN TIME AND WE CAN DO THE SAME THING FOR OUR INTERACTIVE PLAYGROUNDS BECAUSE IT CAN REALLY HELP IN UNDERSTANDING THE CASES LIKE FOR EXAMPLE
IT CAN INTERPRET THE OPEN64 FUNCTION
IT CAN MAKE OUR EXAMPLES EVEN MORE CLEAR BECAUSE THESE HINTS CAN BE SHOWN AS A USER TYPES CODE AND THEY CAN PROVIDE CONTEXT INFORMATION ALMOST LIKE IN THE CASE OF IDS
IT CAN OUTPERFORM RASTERS LIKE CAIRO
IT CAN PRODUCE THESE TRACE FILES AS OUTPUT WHICH YOU CAN STILL LOAD INTO A GTKWAVE OR OTHER TRACE VISUALIZERS
IT CAN THROW THEM ON THE HEAP AND THEN GO BACK AND LOOK FOR THEM LATER
IT COMES IN TWO PARTS AND THE FIRST DESCRIBES THE FORMAT AND THE SECOND PART IS A CONTIGOUS AMOUNT OF MEMORY CONTAINING THE INSTRUCTS IN AN ARRAY
IT CONTAINS MANY DIFFERENT COMPLEX ELEMENTS AND IS DIFFICULT TO BUILD MANUALLY WITHOUT MAKING MISTAKES
IT COSTS YOU LATER IN TERMS OF PERFORMANCE BUT IT'S REALLY HELPFUL IN TERMS OF DEVELOPER TIME AND LOTS OF THINGS IT DOESN'T MATTER WHAT THE CONSTANT TIME COST IS BECAUSE IT'S JUST GLUE
IT COULD IN FACT BE AN ADVANTAGE AND IT COULD HELP STUDENTS TO BUILD BETTER HABITS
IT DEFINES A PERIOD OF TIME OF ONE DIVIDED BY FREQUENCY
IT DEPENDS ON WHEN IT IS INSIDE AN OBJECT
IT DEPENDS SO MUCH
IT DIDN'T HAVE TO WORK OUT THAT WAY BUT WE CAN DO THIS BECAUSE A GO BOARD ONLY HAS 19 POINTS ALONG EACH AXIS WHICH MEANS WE ARE NOT USING THE FULL RANGE OF A BYTE
IT DOES LOOK INTERESTING
IT DOES NOT EMIT
IT DOES THIS WITH TWO FILES
IT DOES WORK WELL FOR PERFORMANCE
IT DOESN'T GIVE YOU AN ERROR CODE FOR EVERY SINGLE ERROR MESSAGE
IT DOESN'T HAVE TO BE THIS WAY
IT DOESN'T MAKE SENSE TO ADD VOLUME TO A LENGTH FOR EXAMPLE AND USING THESE KIND OF PHANTOM DATA TYPES HAS HELPED US EXTENSIVELY AND OPTIMIZED OUR DEVELOPMENT PROCESS
IT DOESN'T WORK
IT FINDS BETTER LINTS THAN THIS ONE
IT GETS THE JSON DOCUMENTS AND THEN IT HELPS YOU UNDERSTAND HOW TO DO THINGS
IT HAS A LOT OF I SAY CASE STUDIES SO IT SHOULD BE TO BE HONEST I NEED SOME MORE TIME TO DIGEST YOUR REPRESENTATION I KNOW
IT HAS A SINGLE STRUCT CALLED BYTEARRAY WHICH HAS A MUTABLE POINTER TO U8
IT HAS A SUPER COOL FEATURE THAT NONE OF THE OTHER INTERPRETERS HAS AND IT IS THAT IT CAN DETECT ALMOST ALL CASES OF UNDEFINED BEHAVIOUR WHILE RUNNING OUR CODE
IT HAS A SUPPORT FOR MULTIPLE LANGUAGESISM THERE IS THE RUST GDB WHICH IS A WRAPPER TO PROVIDE A MORE EASIER UNDERSTANDING
IT HAS ABSTRACT OVERHEAD AND DEEP BINDING TO THE LLVM
IT HAS GREAT DOCUMENTATION A LOT OF TEMPLATES HOW TO START YOUR OWN PROJECT AND OF COURSE HOW TO USE YOUR CARGO FILE AND BASIC TEMPLATES BUT IT ALSO HAS MANY EXAMPLES FOR EVERY AVENUE OF WORK
IT HAS OVER 400 LINT INCLUDES AND THESE ARE PRETTY AWESOME AND I HIGHLY SUGGEST YOU TO HAVE CLIPPY IN YOUR TAR AND AT LEAST DEVELOPMENT WORK SO YOU CAN FIND COMMON BUGS OR COMMON IMPROVEMENTS
IT HAS THREE METHODS
IT HAS TOO MUCH MAGIC IN AND OF ITSELF
IT HELPS YOU BY HAVING THEM IN THE TEST FOLDER
IT INSTALLS AND MANAGING MULTIPLE RUST TOOLCHAINS
IT INTO SHAPES SNAPPY
IT INTRODUCES A NEW PRIMITIVE CALLED SPAN
IT INVITES US ARTISTS TO REVERSE ENGINEER OUR OWN THOUGHT PROCESS AND DECONSTRUCT IT INTO AN ALGORITHMICAL FORM
IT IS A CLONE AND IT WORKS AS WELL AS A REGULAR TO SHOW FOR THIS KIND OF PROJECT
IT IS A COMMON OPEN SOURCE THAT ALLOWS YOU MULTIPLE COMPILER FRONTENDS TO USE A COMMON LANGUAGE SERVER SO THAT THE LANGUAGE SERVICE DON'T HAVE TO BE BUILT FOR EACH COMPILE OR IDEA
IT IS A DYNAMIC PROBLEM SOLVING OF SIMPLIFYING THE OBJECT OF DEPICTION WHILE KEEPING THE PERCEPTUAL ESSENCE
IT IS A FUN PROJECT FOR YOU TO TRY FOR YOURSELF AND CHILDREN
IT IS A GRAPH OF LANGUAGE SYSTEMS LIKE RUST
IT IS A KEY OR A VALUE
IT IS A LITTLE NEW
IT IS A LOT
IT IS A MULTIPLEXOR
IT IS A PRETTY STANDARD REJECT PROJECT FOR DEBUGGING IN LINUX
IT IS A VERY SIMPLE SET OF LOGS
IT IS ALSO THE POINT I AM TRYING TO MAKE
IT IS AN ENUM NAMED VALUE CONTAINING ALL THE DIFFERENT KIND OF VALUES IN A GRAPHQL QUERY LIKE NUMBERS AND OBJECTS AND SO ON
IT IS BETTER THAN SEARCHING FOR REDUNDANCY BY SCANNING MANY VALUES
IT IS COMMON TO LOG THE JSON
IT IS COMMON TO STORE GRAPHQL QUERY AS A STRING EMBEDDED IN JSON ALONGSIDE THE GRAPHQL VARIABLES
IT IS COOL
IT IS CULTURE AND TECHNOLOGY
IT IS DEFINED BY BRETT VICTOR IN ESSAY OF THE SAME NAME AS A SET OF DESIGN PRINCIPLES THAT HELPS PROGRAMMERS TO UNDERSTAND AND SEE HOW THEIR PROGRAMS EXECUTE
IT IS EASY TO PERCEIVE THE FINAL ARTWORK AS THE OUTCOME OF A LINEAR PRE CALCULATED PATH LIKE AN ARTIST JUST SITS DOWN AND DOES ART
IT IS FORCED TO PLACE STROKES EVEN IF IT IS NOT PERFECT
IT IS IMPACTING SOME PROBLEMS
IT IS IMPORTANT TO HAVE AWARENESS OF THE IMPLICATIONS OF WHAT HAPPENS WHEN YOU USE MISUSE UNSAFE CORRECTLY OR IF SOMEONE ELSE DOES
IT IS JUST SOME QUICK TOOLING
IT IS JUST THE SAME AMOUNT OF WORK IT WOULD TAKE TO USE ANY SERIALIZATION FORMAT
IT IS JUST THE VALUE IS PROBABLY 0 NEGATIVE 1 OR 1
IT IS MORE THAN LOGGING LIBRARY BUT PROVIDES THE SAME SIMPLE API FOR CONSUMERS
IT IS MOSTLY INFINITE LOOP
IT IS NICE FOR SHARE NOTHING THREAD SAFETY IN RUST
IT IS OKAY TO LIMIT YOURSELF
IT IS SLOW BECAUSE THE SERIALIZATION FORMAT USED BY THE JAVASCRIPT RUN TIME TO REPRESENT OBJECTS INTRODUCED DATA DEPENDENCIES
IT IS STILL NOT THE RUN YOU WILL USE WHEN YOU RUN CARGO OR ANY OTHER RUST TOOL
IT IS THE DATA DEPENDENCIES THAT MAKE WRITING A CORRECT JSON PARSER A CHALLENGING ENGINEERING PROBLEM IN THE FIRST PLACE
IT IS THOUGHT IN TERMS OF PARSING DATA IN THIS CASE AN URL WHICH IS A STANDARDIZED SERIALIZATION HAVING A PATH AND FOLLOWED BY A TRANSFORM AND LASTLY A SERIALIZATION AND IN THIS CASE AN HTTP RESPONSE
IT IS VERY UNLIKELY THAT WE WILL JUST STUMBLE UPON A GOOD PAINTING
IT IS WORTH TAKING A MOMENT TO CONSIDER HOW A GENERAL PURPOSE ALGORITHM LIKE DEFLATE WHICH IS THE ALGORITHM USED BY JESUP WHICH SEARCHES FOR REDUNDANCY IN THE METHOD
IT LETS ME DO
IT LOOKS LIKE IT SHOULD BE A GOOD OVERVIEW FOR THE NEWBIES
IT LOOKS MAYBE TIGHTER THAN BEFORE
IT LOOKS RANDOM INDICATING THE DATA IS DIFFICULT TO PREDICT AND THEREFORE DIFFICULT TO COMPRESS
IT MEANS THAT WE DON'T DO ANYTHING WHILE THE ECHO IS HIGH
IT MIGHT CHANGE OR USING RANDOM NUMBER GENERATORS
IT MIGHT SEEM LIKE A LOT OF COMPONENTS FOR ONLY THREE ENTITIES IT
IT NEVER HAPPENED AND THAT I'VE FELT SO WELCOMED ANYWHERE
IT POINTS AT WHERE ON THE STACK WE CAN FIND THE LOCAL VARIABLES FOR THE CURRENT FUNCTION
IT POINTS TO THE PART OF THE CODE THAT CAUSES THIS UNDEFINED BEHAVIOUR AND IS APPOINTED A REFERENCE
IT POPS OUR STATUS VALUE AND IT POPS REGISTER 1 AND ZERO
IT PRESENTS IN THE TERMINAL RIGHT
IT PROVIDES A VERY SIMPLE API TO HAVE YOUR OWN LOG IMPLEMENTATION
IT REALLY WORKS GREAT AND I WOULD RECOMMEND IT HEARTFULLY
IT RECEIVES AN INDEX IT TAKES THIS POINTER CASTS IT TO A USIZE AND THEN ADDS THE INDEX TO IT AND CASTS THAT INTEGER BACK TO A POINTER AND OFFSETS A POINTER BY ADDING INDEX TO IT AND THEN WE REFERENCE IT
IT REFLECTS THE ARCHITECTURE OF THE SYSTEM
IT REQUIRES WE USE GRPC IN BETWEEN AND WE CAN SHARE SOME OF THOSE DEFINITION FILES SO THAT WE CAN DO IT EASILY AND TRANSLATE THEM TO BOTH SIDES
IT RETURNS A DOG IN THE OKAY CASE AND A STRING IN THE ERROR CASE
IT RUNS THE CARGO COMPELLER THE FULL CARGO ON EVERYTHING
IT RUNS WHEN YOU'RE RUNNING A STANDALONE
IT SAYS MEMORY ACCESS POINTER MUST BE IN BOUNDS AT OFFSET 11 BUT IT IS OUTSIDE THE POUNDS OF THE ALLOCATION WHICH HAS SIZE 10
IT SEEMS LIKE ECS IS A POPULAR SOLUTION FOR GAMES
IT SEEMS LIKE SOMEONE IS READING THE 11TH PROCEDURE WITH TEN 11THS
IT SEEMS LIKE THAT'S ALL OF THEM
IT SENDS A GET REQUEST AND OUTPUTS THE RESPONSE
IT SHOULD BE INFORMATIVE
IT STARTS WITH THE SERVO UNIT THAT IS ROTATED TO THE FRONT AND THEN THE WHEELS ARE GOING TO MOVE FORWARD
IT SURE WON'T SPILL YOUR BEANS
IT TOOK A WHILE WHILE I UNDERSTOOD TOMORROW MIRI SPECIFIC STUFF BUT IT HELPED ME A LOT TO UNDERSTAND HOW THE COMPILER WORKS AND GET INVOLVED IN OTHER STUFF THAT I WOULDN'T BE ABLE TO DO OTHERWISE
IT TOOK ME LONGER THAN I INITIALLY WOULD HAVE THOUGHT BUT IT WAS FUN AND I WOULD SAY ULTIMATELY IT FELT GOOD WRITING RUST BECAUSE EVEN IF I AT TIMES WAS QUITE CHALLENGED LEARNING IT I ALWAYS FELT THAT THE CODE THAT I WAS WRITING WOULD ACTUALLY WORK AND THAT I WOULD ACTUALLY BE ABLE TO CHANGE IT IN A COUPLE OF MONTHS� TIME
IT TRIES HARD NOT TO BE BAD IN THAT CASE WHERE THERE ARE NO ARRAYS BUT THERE ARE SOME FUNDAMENTAL TRADEOFFS THAT WHEREVER TREE BUF CAN OPTIMIZE WITH ARRAYS
IT TURNS OUT THAT THE GENERAL PURPOSE INSTRUCTIONS ON VARIOUS PLATFORMS TAKE A VARIABLE NUMBER OF CYCLES
IT TURNS OUT WE NEED TO ADD SOME KIND OF OPTIMISATION BARRIER FOR THE SECRET DATA
IT USES A FEATURE OF THE GPU CALLED THE TENSILE BUFFER TO RATHER THAN DOING THE KIND OF MATHEMATICALLY HARD OF BREAKING A CURVE INTO TRIANGLES IT DRAWS A POINT AND DRAWS A FAN OF TRIANGLES OUT FROM THAT POINT IN SUCH A WAY THAT THEY ALL CANCEL EACH OTHER OUT TO LEAVE ONLY THE POINTS INSIDE THE SHAPE FILLED AND THE POINTS OUTSIDE THE SHAPE EMPTY
IT USES EMBEDDED HAL A HARDWARE ABSTRACTION LAYER FOR THE EMBEDDED CONTEXT
IT USES FILE OPEN SO EVENTUALLY IT WILL USE OPEN64
IT USES THE STENCIL AND CAN HAVE COVER APPROACH TAKES A HYBRID APPROACH WITH TEXT RENDERING TEXT ON THE CPU AND SHAPES ON THE GPU
IT WAS A PLEASURE
IT WAS CHOSEN�TO BE AN OFFICIAL GAME FOR THE AMETHYST ENGINE
IT WAS CLEAR THERE WERE AREAS OF AMETHYST CARLO HAD EXPLORED THAT I HAVEN'T
IT WAS DIFFICULT FOR ME TO CONTINUE CONTRIBUTING TO BECAUSE WITH A COUPLE OF HOURS TO WORK ON A FEATURE I WOULD NEED TO REORIENT MYSELF TO WORKING ON SOMETHING NEW
IT WAS GREAT
IT WAS GREAT TO HAVE YOU HERE
IT WAS HARD TO WRITE AND IT HAD MEDIOCRE PERFORMANCE AND SO I STARTED PROTOTYPING IN PROLOG
IT WAS INFORMATIVE TO ME AS WELL
IT WAS INITIALLY A PROJECT FOR LEARNING RUST
IT WAS ORIGINALLY INSPIRED BY MANY IMPLEMENTATIONS OF GENETIC ALGORITHMS AVAILABLE ON THE INTERNET
IT WAS PROBABLY THE NUMBER ONE INSPIRATION FOR OCHRE
IT WAS REALLY DESIGNED FOR DATASETS AND NOT DATABASES SO WE WERE USING ORCHESTRATION LOGIC ON TOP OF IT WHERE WE WOULD JOURNAL TRANSACTIONS AND STUFF LIKE THAT
IT WAS REALLY INTERESTING
IT WAS REALLY REALLY HARD TO FIND THE SOURCE OF THESE CRASHES AND THAT WAS A PERSISTENT SOURCE OF PROBLEMS FOR US
IT WAS RUNNING
IT WAS SOMETHING LIKE 434 LINES OF CODE
IT WAS THE ONLY TIME THAT I USED MY OWN NAME AND MY OWN PICTURE ON THE INTERNET AND I NEVER DO THAT BECAUSE YOU KNOW YOU'RE ALWAYS AFRAID OF MEAN COMMENTS AND ABUSE BUT YES LIKE FROM DAY 1 IT NEVER HAPPENED
IT WAS THE SUMMER OF 2017 AND I FINISHED MY USER THE AND I HAD NO IDEA ABOUT SEARCHING ALGORITHMS
IT WAS UGLY AND I NEVER REALLY SHOWED IT TO ANYONE EXCEPT A COUPLE OF FRIENDS
IT WAS VERY WELL RECEIVED AND GREAT TALK
IT WASN'T DESIGNED THAT WAY
IT WILL BE TL DR VERSIONS AND WE HAVE SEPARATE TALKS ABOUT BOTH OF THEM IF YOU WANT TO LEARN MORE
IT WILL EXPAND AUTOMATICALLY ONCE THE SPAN IS STARTED AND IT WILL CLOSE THE SPAN ONCE THE FUNCTION IS ENDED
IT WILL INDICATE WHETHER WE ARE IN THE FOUR SMALLEST VALUES AND THE MOST LIKELY CASES 0 1 NEGATIVE 1 AND 2 OR THE UNLIKELY VALUE CASE FOR ALL THE OTHER VALUES
IT WORKS
IT WORKS AS INTENDED
IT WORKS BY BASICALLY BREAKING DOWN EACH BLOCK INTO INDIVIDUAL FUNCTION THAT REPRESENTS A SINGLE EXECUTION STEP
IT WORKS KIND OF DIFFERENTLY
IT WOULD BE SILLY TO WRITE THEM
IT'S A
IT'S A BIG HEADACHE
IT'S A COMMON PATTERN USED IN GAME DEVELOPMENT THAT MAKES IT EASY TO COMPOSE OBJECTS IN A GAME BECAUSE COMPONENTS CAN BE ARBITRARILY ADDED TO ENTITIES
IT'S A COMPANION AND COMPLEMENT LANGUAGE TO C AND C PLUS PLUS
IT'S A GOOD COMMUNITY
IT'S A GREAT ENGINE THAT PEOPLE SHOULD TRY TOO
IT'S A HYBRID APPROACH LIKE THAT IT'S NOT PURE GPU
IT'S A SIMPLE REAL WORLD BUTTON HANDLING LIBRARY
IT'S A SPACE SHOOTER GAME WITH ENEMIES FROM THE TOP OF THE SCREEN
IT'S A TOOL IN RUST THAT'S MODERN ONLINE BOOK IT IS�MARKDOWN FILES
IT'S A TRADEOFF IT'S NOT A PURE WIN
IT'S A VERY SIMPLE EXAMPLE
IT'S ABOUT TIME THAT I TELL YOU ABOUT MY PROJECT
IT'S ACTUALLY QUITE STRAIGHTFORWARD ONCE I WORKED THROUGH ALL OF THAT
IT'S ALMOST ALWAYS WORTH DOING ANALYSIS AHEAD OF TIME TO MAKE SURE THAT YOU DON'T RUN OUT OF MEMORY
IT'S ALSO SIMPLER TO IMPLEMENT AND I HAVE SOME EXPERIENCE IN IMPLEMENTING ON ACID DATABASES AND SO I KNOW A LOT ABOUT THE DIFFICULTIES THAT YOU CAN ENCOUNTER WHEN TRYING TO PAGE IN
IT'S ALSO VERY EASY
IT'S AN ATTEMPT TO STRIKE A BALANCE CLOSER TO TESSELLATION
IT'S AN ELECTRONICS SUITE
IT'S AN EXAMPLE BASED ALGORITHM FOR IMAGE GENERATION MEANING YOU CAN GIVE IT AN EXAMPLE IMAGE AND IT WILL GENERATE MORE SIMILAR LOOKING IMAGES
IT'S AN INTERESTING THING TO DO WITH GPUS THEY'RE GOOD AT IT
IT'S AN INTERRUPT
IT'S AS CLOSE AS YOU CAN GET TO REALLY UNDERSTANDING EXACTLY WHAT THE MACHINE SEES WITHOUT READING THE BINARY ITSELF
IT'S BECAUSE I WAS TALKING IN METRES AND THEN CENTIMETRES AND THEN I FORGOT TO DO THAT TO EXPLAIN IT
IT'S BEEN AMAZING
IT'S BEEN GREAT SEEING IF YOU GO BACK AND LOOK AT SOME OF THE EARLIER PULL REQUESTS FOR HOW TO IMPROVE RUST'S ERROR MESSAGES
IT'S BEEN VERY GOOD TO US
IT'S CALLED THAT BECAUSE LATER THINGS THAT YOU DRAW PAINT OVER EARLIER THINGS
IT'S COMPLETELY DIFFERENT
IT'S CPU GPU HYBRID
IT'S DIFFICULT TO DEFINE A BALANCE TO WHAT'S AT THE TASK AT HAND AND UNNECESSARY INFORMATION
IT'S EASY AND IT'S REALLY COOL AND FUN AND EASY
IT'S ENTITY COMPONENT SYSTEM
IT'S EVERYWHERE
IT'S FREQUENTLY ABBREVIATED IR
IT'S GOAL IS TO ENFORCE THAT THE MAIN MODEL AND MAINTAIN DATA INTEGRITY
IT'S GOING TO WORK FINE
IT'S JUST A FEW THINGS TO WORRY ABOUT
IT'S JUST KIND OF RIGHT THERE AND YOU CAN JUST KIND OF ADDRESS IT AND GO ON WITH YOUR DAY
IT'S LESS GPU
IT'S LIKE MACHINE LEARNING WHERE YOU NEED TO HAVE REVISION CONTROL OF YOUR DATA SETS AND THERE IS ANY KIND OF LARGE SCALE GRAPH MANIPULATION IF YOU WANT TO IF YOU WANT TO KEEP REVISIONS AND BE ABLE TO PIPELINE YOUR DATA THAT'S WHERE WE WOULD USE IT
IT'S LIKELY THEY'RE GOING TO BE AROUND A LOT LONGER ALSO
IT'S MUCH MORE LIMITED THAN FOR INSTANCE ARM
IT'S MUCH MORE POWER EFFICIENT THAN A CPU
IT'S MUCH MORE RELEVANT
IT'S MY FAULT
IT'S NECESSARY TO MOVE TO ANOTHER LANGUAGE LIKE C PLUS PLUS
IT'S NOT A BUG IN CODE I WROTE
IT'S NOT A SILVER BULLET FOR YOUR UNDEFINED BEHAVIOUR PROBLEMS
IT'S NOT AVAILABLE WHEN ISOLATION IS ENABLED
IT'S NOT BUILT AND TESTED AUTOMATICALLY BY THE CONTINUOUS INTEGRATION SERVER
IT'S NOT EXACTLY CLEAR WHETHER OR NOT THAT'S A GOOD OR A BAD THING
IT'S NOT MUCH CODE
IT'S NOT SO MUCH I THINK WHAT YOU HAVE TO REFRAIN FROM AND THAT'S WHAT I THINK I WRITE A LOT OF PYTHON
IT'S NOT SURPRISED AND THERE WILL BE FLOWS WITH IT
IT'S NOT THE MOST COMPLEX BUG
IT'S ON GITHUB
IT'S ON THE LIBRARY FOR OPENING FILES
IT'S ONLY 5 YEARS OLD AND ONLY 5 YEARS SINCE THE 1 0 RELEASE AND PYTHON IS 30 YEARS OLD AND C PLUS PLUS IS AROUND 40
IT'S POSSIBLE THAT SCIENTIFIC PAPERS WILL BE PUBLISHED BASED ON THE RESULTS
IT'S POSSIBLE TO MAKE TWO OF THE ASSEMBLY MODELS WORK TOGETHER
IT'S REALLY GREAT
IT'S ROBUST IT'S SIMPLE
IT'S SAYING SOMETHING POTENTIALLY DANGEROUS IS HAPPENING HERE
IT'S SERIALIZATION ALL THE WAY DOWN
IT'S SIMILAR TO OCHRE IT'S MINIMAL LIBRARY FOCUSED ON PORTABILITY AND WORKING ON AS MANY SITUATIONS AS POSSIBLE
IT'S SLIGHTLY DIFFERENT THAN 3 WHEN 1 IS ADDED TO ITSELF
IT'S SO GOOD THAT YOU ALL COULD NOT SEE ME DURING THE TALK BECAUSE IT WAS JUST ME GRINNING FROM EAR TO EAR AND CLAPPING MY HANDS OFF
IT'S SO GREAT THAT YOU ACTUALLY WENT FOR IT AND THAT YOU FELT SAFE AND COMFORTABLE TO DO SO
IT'S SOMETHING WE WILL PROBABLY NEED TO DO SOME REFACTORING TO ADJUST FOR THAT IN THE FUTURE
IT'S SORT OF
IT'S SUBTLE BUT I THINK IT GIVES AN EXTRA PUSH TOWARDS BELIEVABILITY THAT THERE IS AN ARTIST'S THOUGHT PROCESS BEHIND EACH BRUSH PLACEMENT
IT'S SUPER GREAT
IT'S TAUGHT IN RACKET AND THEN 2 IS TAUGHT IN JAVA AND INTRODUCES STUDENTS TO OBJECT ORIENTED PROGRAM
IT'S THE BINDING OF ISAAC
IT'S THE FRACTION OF TIME WHERE THE SIGNAL IS ACTIVE
IT'S THE MANUAL
IT'S USING MORE THAN THE RATIONING
IT'S VERY EASY TO GET ORGANIZED
IT'S VERY RARE I FIND MYSELF IN THE NEED OF ADVANCED FEATURES WHEN DOING THIS KIND OF ART TOOLS
IT'S VERY RARE THAT YOU WOULD HAVE AN RFC THAT SPECIFIES MULTIPLE PROTOCOLS SO IF YOU WANTED TO MAKE AN IPV6 GENERATOR GO AHEAD RUN IT ON THE RFC
ITEMS ARE LISTED FOR A PRICE
ITEMS FUEL THE PROGRESSION OF THE PLAYER
ITS
ITS RELATIONSHIP TO THE OUTSIDE WORLD
ITS WIDTH IS THE SIZE OF THE FILE AND BYTES
JIN MINGJIAN USES RUST TO ENHANCE
JIN THANKS FOR THE PRESENTATION
JSON CAN UTILIZE BOTH
JSON STRINGS ARE ALSO QUOTED STRINGS MEANING THE SAME DATA GO THROUGH ANOTHER ALLOCATION AND DECODE STEP
JUST LISTEN ENOUGH TO GET A HIGH LEVEL FIELD FOR THE CONCERN THE CODE ADDRESSES AND DON'T WORRY ABOUT THE DETAILS
JUST TRYING TO GO AHEAD AND COLLECT SOME NUMBERS INTO A VECTOR OF UNSIGNED THIRTY TWO BIT INTEGERS
KNOW YOUR CHALLENGE
LARGE PARTS OF THIS FERARI ARE MADE FROM METAL
LASTLY RIGHT NOW FUNDIES�2 TAKES ADVANTAGE OF JAVA'S PASS BY REFERENCE BY DEFAULT IN ORDER TO AVOID HAVING TO TEACH STUDENTS HOW TO PROPERLY MANAGE SCOPING OF VARIABLES
LASTLY WE
LASTLY WE CAN FINALLY COPY THE DATA FROM OUR TEXT INTO THE BUFFER ASSUMING ALL OF THE PREVIOUS CODE IS CORRECT
LASTLY WE'RE GONNA LOOK AT SAMENESS OF DATA
LATER WE MOVED TO LIBRARY AND C PLUS PLUS CALLED HDT AND WE USED THAT AS OUR STORAGE LAYER WHICH RADICALLY IMPROVED THE PERFORMANCE OF THE APPLICATION
LAZY STATIC INTERNALLY DEPENDS ON A GRID AND INTERNALLY
LEARN THE CONCEPTS THE TOOLS
LEARN THE CONTEXT OF THE LANGUAGE
LEARNABLE PROGRAMMING WITH RUST
LEARNING ANYTHING REALLY IS WHY DO YOU THINK IT MIGHT BE HARD
LEARNING RUST WITH HUMILITY AND IN THREE STEPS
LEFT FOR DEAD RUST PROJECTS TO REVIVE
LET ME CHECK THE CHAT
LET ME EXPLAIN TO YOU WHY AT THIS POINT IT'S REALLY HARD FOR US TO GUARANTEE THAT THE COMPILER IS CONSTANT TIME
LET ME GO BACK TO THE EXAMPLE REALLY QUICKLY
LET ME GO OVER A LITTLE BIT OF MY EARLIER PROCESS THAT LED ME TO THE CURRENT STATE OF OCHRE
LET ME OPEN A NEW FIREFOX WINDOW HERE
LET ME SHOW YOU
LET ME SHOW YOU AN EXAMPLE OF THIS
LET'S CALL IN TO OUR INTERRUPT SERVICE ROUTINE
LET'S COMPARE THE METHODS IN A MATRIX
LET'S DIG INTO THAT JUST A BIT MORE
LET'S DISCUSS A LITTLE BIT UNDEFINED BEHAVIOUR
LET'S DO A DEMO WITH THE SAME CODE I WAS SHOWING YOU BEFORE
LET'S DO A LITTLE POINT HERE
LET'S FIRST SEE THE INSTALLATION
LET'S GET STARTED
LET'S GET TO THE FUN STUFF
LET'S GO AHEAD AND DO THAT
LET'S GO TO THE BIT STRING WHEN WE WERE EXPLAINING OUR CUSTOM TYPES
LET'S IMAGINE THIS TWO D SPACE IS A SPACE DEFINED BY 100 BRUSHES AND A DOT IN THE SPACE REPRESENTS A PARTICULAR CANVAS APPEARANCE DEFINED BY OUR 100 BRUSHES ARE CONFIGURED
LET'S IMAGINE WE CAN DRAW A SINGLE BRUSHSTROKE WHICH IS PARAMETERISED BY ITS SCALE AND VALUE
LET'S IMAGINE YOU'RE SOMEONE NEW TO ASYNCHRONOUS PROGRAMMING IN RUST AND YOU WANT TO LEARN MORE ABOUT IT
LET'S LOOK AT ANOTHER COMPONENT OF OUR COMPUTER MODEL THE PERIPHERALS
LET'S LOOK AT ANOTHER EXAMPLE OF A BLACK BOX
LET'S LOOK AT ONE MORE EXAMPLE OF HOW WE CAN BUILD CAPABILITIES INTO A SERIALIZATION FORMAT AND HOW RUST WORKS WITH US TO TAKE ADVANTAGE OF THOSE CAPABILITIES
LET'S LOOK AT THE FUNCTION TO WRITE THE VERTEX
LET'S LOOK INSIDE THIS COMPILER
LET'S MATCH THIS UP QUICKLY TO WHAT WE HAD
LET'S SAY THE ENGINE IS THE SAME THE SAME ENGINE BUT IN A DIFFERENT CAR LET'S SAY
LET'S SAY THE RUST COMPILER WAS WRITTEN UNDER THE SAME ASSUMPTION HOW PROGRAMS WORK
LET'S SEE WHAT THAT ACTUALLY MEANS
LET'S START BY DEPHENOTYPING THE PROBLEM
LET'S START WITH THE TYPESCRIPT CODE
LET'S TAKE A LOOK AT A DIFFERENT DATASET
LET'S TAKE A LOOK AT THE MEMORY REAL BRIEFLY
LET'S TALK ABOUT THE COMPILATION AND TALK ABOUT FORMATTING AND LINTING
LET'S WALK THROUGH THIS
LIFETIME IS AN ENGINEERING EXCELLENCE IN RUST BUT IT MAYBE MAKE CODE COMPLEX
LIFETIMES ARE DIFFICULT FOR EVERY RUST TO LEARN
LIFETIMES COULD BE INTRODUCED IN THE NEXT COURSE
LIGHTNING FAST QUERY WE HAVE NO TIME BUDGET FOR YOU TO INITIAL THE LOAD FOR COORDINATION
LIKE DISSEMINATING THIS CULTURE OF IMPROVING ERROR MESSAGES TO OUTSIDE RUSTC
LIKE EITHER IN RUSTC OR CLIPPY OR MAYBE UPLOADED FROM CLIPPY TO RUSTC
LIKE FOR EXAMPLE THE RECENT C STRING POINTER LINT
LIKE I USE SOME LITTLE PARTS HERE IN THERE AND I IMPLEMENTED A LOT OF THINGS BECAUSE I LIKE THEM
LIKE IN THIS EXAMPLE SPACESHIP TO ENEMY AND SPACESHIP TO ITEMS WERE THEIR OWN EVEN TYPES
LIKE LET'S CONSIDER THIS SHEEP FOR EXAMPLE
LIKE THIS MEME SHOWS
LIKE YEAH
LIKE YOU KNOW
LIKEWISE
LLVM IS A LIBRARY THAT IT CONTAINS ALL OF THE COMMON PARTS OF COMPILERS
LONG TERM GOALS AN EXAMPLE ADDING A
LOOKING AT THE LIST OF DIFFERENT VALUES HERE WE SEE THAT THE ENTRIES FOR VARIABLE EMUM AND OBJECTS ARE GENERIC OVER TEXT
LOOKS LIKE A LONG ONGOING PROJECT
LOVED IT
LOW LEVEL IR IS JUST FOR PLATFORM RELATED OPTIMIZATION
MACRO PROGRAMMING IS QUITE INTERESTING
MACROS ARE GREAT AT REDUCING REDUNDANT CODE
MAKE CUSTOMERS HAPPY
MAKING SURE THAT I HAVE A REALLY GOOD MENTAL MODEL OF EVERYTHING THAT'S GOING ON
MAKING SURE THAT THEIR CODE WORKS PROPERLY ALL OF THEIR LOGIC AND THEN EVENTUALLY THEY GET DEEPER INTO THE MACHINE LEVEL IDEAS
MAKING THE ERROR MESSAGES A HIGHER PRIORITY IN YOUR LANGUAGE ECOSYSTEM AT THE END OF THE DAY
MANUAL MEMORY MANAGEMENT I THINK THAT'S THE BIGGEST PROBLEM
MANY ARE AVAILABLE ONLINE AMAZON
MANY NICE MACROS
MANY OF YOU IF YOU HAVE ALREADY USED RUST YOU KNOW THAT WE HAVE REFERENCES WE HAVE AMPERSAND MUT AND AMPERSAND FOR MUTABLE AND IMMUTABLE REFERENCES BUT THOSE TYPES HAS LIKE THESE TWO BROTHERS OR SISTERS SIBLINGS WHATEVER
MANY TIMES FROM DIFFERENT ANGLES
MAP REDUCE AND FORK JOIN ARE THERE
MATTER
MATTHIJS IS THERE A LAST THING THAT YOU WOULD LIKE TO ADD BECAUSE WE HAVE A FEW MINUTES ALSO STILL LEFT
MATTHIJS OFF HIS OWN BAT WENT OUT AND WROTE A PROTOTYPE IN RUST OF THE SUCCINCT DATA STRUCTURES THAT WE NEEDED TO REPLACE HDT AND LIKE A SIMPLE LIBRARY AROUND IT AND IT LOOKED REALLY VERY PROMISING
MAX OROK SHOWS SCIENCE NOT FICTION
MAYBE
MAYBE EVEN ONE PERSON OR A COUPLE PEOPLE
MAYBE HOW I DO ALLOW MYSELF TO USE THIS PARTICULAR� THIS ONE CRATE THAT I WILL THEN LEARN ABOUT
MAYBE I CAN INTRODUCE MY OWN QUESTION HERE
MAYBE JUST DOWNLOAD IT MAKE SOME CHANGES AND SEE IF IT STILL COMPILES
MAYBE JUST GO TO GITHUB AND GOOGLE FOR COMMANDLINE TOOL LOOK FOR COMMANDLINE TOOL
MAYBE ONE DAY IN THE FUTURE
MAYBE ONE OF YOU WANTS TO DO IT
MAYBE WE HAVE NEVER USED EXTERNAL FUNCTIONS IN OUR PROJECTS
MAYBE WE WANT FASTER CODEGEN
MAYBE YOU DON'T LIKE TO THINK IN TERMS OF IMPLEMENTING
MAYBE YOU FEEL THIS CHARACTERIZATION OF THE COMPUTER AS DRIVEN BY SERIALIZATION TO BE REDUCTIONIST
MAYBE YOU PREFER TO THINK IN ABSTRACTIONS
MAYBE YOU WANT TO USE IT BECAUSE YOU ACTUALLY WRITE IN SAFE AND YOU WANT TO BE SURE YOU'RE NOT CAUSING UNDEFINED BEHAVIOUR
MAYBE YOU'RE EXPECTING THAT MIRI CATCHES SOMETHING AND IT DOESN'T OR MAYBE IT IS THE OTHER WAY ROUND
MEMORY
MEMORY CAN'T LIVE WITH IT CAN'T LIVE WITHOUT IT
MEMORY SHARING NEEDED HERE WE LIST SOME REASONS
METAL FABRICATION ITSELF IS A VERY VERY COMPLICATED REALWORLD DOMAIN BUT RUST HAS BEEN AN AMAZING LANGUAGE FOR DEVELOPING THIS SOFTWARE
MICAH CARLO THANK YOU SO MUCH
MIGHT HAVE A PROBLEM WITH ONE PARTICULAR SYNTAX FEATURE THAT YOU HAVEN'T GRASPED AS MUCH AS YOU WOULD LIKE TO
MIRI CAN EMULATE AN ENVIRONMENT INSIDE IT SO WE CAN DO WE CAN USE THE SIZE ENVIRONMENT VARIABLE TO SET THE SIZE OF THE ARRAY
MIRI CANNOT DETECT DATA RACES YET
MIRI IS A VIRTUAL MACHINE FOR RUST PROGRAMS
MIRI IS LIKE THAT BUT FOR RUST
MIRI IS NOT PERFECT
MIRI IST RUST'S INTERPRETER
MIRI RUNS WITHOUT A LOT OF OF THE VALIDATIONS
MIRI UNDEFINED BEHAVIOUR AND FOREIGN FUNCTIONS
MIRI WORKS ALMOST IN THIS WAY
MOST OF MY EMBEDDED EXPERIENCE IS WITH C
MOST OF THE INFORMATION IN TODAY'S TALK IS AROUND MY EXPERIENCE DEVELOPING THE RIGHT HAND THREE AND DEVELOPING SOFTWARE FOR THESE AREAS
MOST OF THE POINTS ABOUT TWO THIRDS LIE ON THESE LINES
MOST OF THE TIME YOU WILL GET YOURSELF INTO A CORNER YOU CAN'T SOLVE LIKE A SO YOU DECONSTRUCT THE OBJECT OF DEPICTION INTO BIG SHAPES FIRST
MOST OF THE TIME YOU'RE GOING TO GET SOMETHING A LITTLE BIT MORE SANE A LITTLE BIT MORE STRAIGHTFORWARD
MOST ONCE IT IS CREATED WE NEED TO DELIVER IT TO REQUIRING THIS FORKLIFT AND TRACK INVENTORY AND KNOW WHEN IT IS FINALLY DELIVERED
MOST SERVO MOTORS HAVE A FREQUENCY OF 60 HERTZ IN SHORT DUTY CYCLES
MOST SOFTWARE IS JUST GLUE CODE AND IF YOU'RE JUST WRITING GLUE YOU DON'T WANT TO BE WORRIED ABOUT LOTS OF DETAILS I THINK
MOSTLY BECAUSE I STARTED OUT ASSUMING I COULD JUST ASSUME ONE TO ONE FROM THE C PLUS PLUS PROGRAM
MOTION AND SHOOTER REFERS TO THE ACCELERATION DECELERATION AND MAXIMUM SPEED VALUES
MOVING CONTROL TO MEMORY AND SAFELY PASSING DATA IS THE NAME OF THE GAME
MOVING FURTHER DOWN IT'S MORE COMPLICATED APPROACHES SUCH AS PATHFINDER WHICH IS A RUST LIBRARY WRITTEN BY PATRICK WALTON
MY APOLOGIES
MY APOLOGIES FOR ALL OF THAT
MY BACKGROUND IS FOCUSED ON FRONT END WEB DEVELOPMENT
MY CAT CHEWED THROUGH MY POWER CORD AND SO IT WAS NOT CHARGING
MY CHILD IS HERE
MY DEVELOPMENT TEAM BUILDS ENTERPRISE SOFTWARE USING THE BROWSER AS THE PRIMARY INTERFACE SO OUR ARCHITECTURE LOOKS VERY MUCH LIKE A WEB APPLICATION WITH A FRONT END AND SOME BACK END PROCESSES
MY EXPERIENCE HAS BEEN THAT THE CHOICE OF REPRESENTATION OF THE DATA IS AN ESSENTIAL FACTOR IN DETERMINING THE SYSTEM'S PERFORMANCE THE ENGINEERING EFFORT REQUIRED TO PRODUCE THE SYSTEM AND THE SYSTEM'S CAPABILITIES AS A WHOLE
MY GOAL HERE IS TO DESIGN A FRESHMAN LEVEL COMPUTER SCIENCE COURSE TAUGHT IN RUST
MY IMPRESSION WHICH MIGHT BE A NAIVE IMPRESSION BUT MY UNDERSTANDING IS THAT THEY'RE PROBABLY EXPENSIVE HARD TO SET UP AND PROBABLY WINDOWS ONLY SYSTEM
MY LAST POINT IS EVEN THOUGH WE ARE COMMUNICATING THROUGH DIRECT COMMUNICATION LINES WE STILL MAKE SURE TO DO PUBLIC CODE REVIEWS THROUGH GITHUB EVEN IF IT IS JUST A SMALL CHANGE
MY MINIMAL DIFFERENCE BEFORE
MY NAME IS AKI
MY NAME IS ANASTASIA OPARA AND I'M A PROCEDURAL ARTIST AT EMBARK STUDIOS A STOCKHOLM BASED GAME DEVELOPMENT COMPANY
MY NAME IS CARLO AND I WILL BE PRESENTING TOGETHER WITH MICAH TALKING ABOUT A TWO D SHOOTER GAME MADE WITH THE AMETHYST ENGINE
MY NAME IS TARUN AND I AM AN ENGINEER AT BUOYANT
MY NAME MAX OROK
MY NAME'S ANDREW DONA COUCH
MY PERSONAL IDEA OF PROGRAMMING LANGUAGES ABOUT LEARNING IN GENERAL WAS ALWAYS THAT YOU ALWAYS BUILD THE CONCEPTS ON THE EASIER CONCEPTS THAT YOU HAVE GRASPED BEFORE
MY PERSONAL REASONS IS THAT I ALWAYS WANTED TO WORK IN COMPILERS BECAUSE I FIND THEM SUPER INTERESTING
MY PLEASURE
MY PRIMARY TOOL HERE IS ACTUALLY C PLUS PLUS
MY SO CALLED HIGH PERFORMANCE WE HAVE SOME LOW LEVEL INQUIRIES HERE
MY SUGGESTION IS TO GO AHEAD AND ADD THOSE
MYSELF PERSONALLY I PREFER IF I HAVE TO DO A LITTLE BIT MORE CODE AT THE SOURCE AND WHICH SAVES ME FROM BUGS LATER ON THIS IS A TRADEOFF THAT I'M COMFORTABLE MAKING AND I WOULD LIKE TO MAKE IN MY CODE
NAMELY THAT GPUS AREN'T CAPABLE OF RENDERING TRIANGLES WITH THE KIND OF ANTI ALIASING THAT YOU NEED FOR SMALL TEXT
NAMING CONVENTIONS DOCUMENTATION AND UNIT TESTING ARE IMPORTANT NO MATTER WHAT LANGUAGE YOU'RE USING
NETWORK PACKET REPRESENTATION IS PROGRAM AGNOSTIC
NEW STUDENTS GETTING INTO PROGRAMMING
NEXT ATTEMPT WAS TO SWITCH OVER TO WEB TECHNOLOGY AND ELECTRON
NEXT I WOULD LIKE TO TALK ABOUT SOME OF OUR IMPRESSIONS OF THE LIBRARY ECOSYSTEM
NEXT IS PACKAGE MANAGEMENT
NEXT NOW THE ENTITY'S CHARACTERISTICS REQUIRED FOR THEM TO FUNCTION IN A GAME
NEXT RUST HAS A TOOL CALLED RUST CLIPPY WHICH MINDS COMMON MISTAKES AND ALSO FIND IMPROVEMENTS
NEXT WE SETUP THE VIEWS AND CALCULATE THE BEGINNING POSITION OF THE DATA WE WANT TO WRITE WITHIN EACH VIEW RELATIVE TO THE DATA SIZE IN EACH VIEW
NEXT WE WANT TO INTRODUCE FUNCTION OBJECTS TO ADD TO EXISTING BEHAVIOR OF TYPES
NEXT WE WILL TALK ABOUT BINARY MANAGEMENT
NEXT WE WILL TALK ABOUT DOCUMENTATION
NEXT WE WILL TALK ABOUT FEATURES
NEXT WE WILL TALK ABOUT IDE EXPERIENCE WHICH IS VERY IMPORTANT IT MAKES DEVELOPER'S JOB EASIER
NEXT WE WILL TALK ABOUT TESTING
NEXT WE WILL TALK ABOUT THE DEBUGGING
NEXT WE WILL TALK ABOUT TRACING
NEXT WE WILL TALK ABOUT WORKSPACES
NEXT WE'RE GONNA HAVE DYNAMIC DISPATCH TO ALLOW STUDENTS TO ACT ON SHARED BEHAVIOR BETWEEN DIFFERENT TYPES
NEXT WE'RE GONNA LOOK AT ERROR HANDLING
NEXT WE'RE GONNA LOOK AT GENERICS
NIGHTLY HAS MANY FEATURES MEET NIGHTLY
NIKITA MAKES RUST INTERACTIVE
NO AMOUNT OF ENGINEERING EFFORT SPENT ON OPTIMIZING THE PIPELINE THAT CONSUMES THE DATA CAN IMPROVE THE SITUATION BECAUSE THE COST IS A REPRESENTATION OF THE DATA
NO DEBUG IS DEFINITELY NOT FAST ENOUGH
NO EACH POINT IS VERY LIKELY TO BE NEAR THE PREVIOUS
NO I THINK I'VE KIND OF SAID EVERYTHING THAT I WANT TO SAY IN THE PRESENTATION MOSTLY
NO IT WAS A LITTLE BIT DIFFERENT BECAUSE IT DIDN'T RUN RUST BUT MIRI YOU HAD TO WRITE THE MIR OF YOUR PROGRAM TOGETHER WITH THE RUST CODE
NO PLEASE YES
NO PROBLEM
NO PROGRESS EFFECTIVELY MADE ON IT
NO QUESTIONS BY NOWISM DO YOU HAVE ANYTHING TO ADD TO YOUR PRESENTATION OR COMMENT
NO SUCH PREDICTION METHOD EXISTS
NOT DOING THIS IS A FAMILIAR MISTAKE THAT WAS MADE WAY BACK SINCE NULL TERMINATED STRINGS IN C
NOT IS BUT CAN BE CHALLENGING LIKE RUST
NOT ONLY ALL YOU'VE DONE BUT ALSO WITH LIKE HANDLING ALL THE TECH ISSUES AND TALKING JUST YOU KNOW I CAN'T BELIEVE
NOT REALLY
NOT RELATED TO AVR BUT I FEEL LIKE THE RELIANCE ON A GLOBAL ALLOCATOR FOR THE STANDARD LIBRARY MEANS THAT OTHER
NOT SAYING THAT FOLLOW YOU MUST
NOT TO PUT MY OWN COMMENTARY
NOTE THIS ISN'T THE BEST PREDICTION ALGORITHM POSSIBLE
NOTICE HOW MUCH BETTER DEFINED THE FACE IS AND HOW IT LOOKS PERCEPTUALLY CLOSER TO THE ORIGINAL
NOW ALL MICROCONTROLLERS HAVE AN INTERNAL CLOCK AND IT IS 16 MEGAHERTZ
NOW I TEND TO LIKE TO WRITE MY SOFTWARE USING LOTS OF UNIT TESTS WITH REALLY GOOD
NOW I WANT TO SHOW THE MOTOR DRIVER
NOW I WILL TAKE QUESTIONS
NOW I WILL TRY TO ANSWER THE QUESTION WHY DOES IT NEED TO BE GPU ACCELERATED
NOW I'M VAGUELY AWARE THAT RUST USES LLVM
NOW IF WE WANT TO GET THAT BINARY DATA FROM THE LOGS IT IS JUST ALLOCATING IS DECODING THE SAME DATA OVER AND OVER UP THROUGH EACH LAYER FOR EVERY FIELD
NOW IN AN EMBEDDED CONTEXT YOU CERTAINLY COULD HAVE A NETWORKING PERIPHERAL ALTHOUGH IT'S NOT UNIVERSAL
NOW IN THE FEATURE SECTION WE HAVE TWO
NOW IT'S NOT ENTIRELY CLEAR WHY THROWING AWAY THE ORIGINAL ERROR AND REPLACING IT WITH AN EMPTY ERROR WOULD MAKE THIS BROKEN CODE WORK PARTICULARLY BECAUSE I KNOW STATICALLY THAT ERROR CASE NEVER ACTUALLY HAPPENS
NOW IT'S PERFECTLY LOOKING ALIVE
NOW LET'S TAKE A LOOK AT THE RUST PROGRAM
NOW LET'S TALK ABOUT DEBUGGING
NOW LET'S TRY SUBTRACTING
NOW OKAY
NOW OUR STATUS SPECIAL REGISTER HAS ITS PRIOR VALUE
NOW OVER TO MICAH TO TALK ABOUT THE IMPORTANCE OF DOCUMENTATION FOR THE PROJECT
NOW RUSTC WE KNOW IS THE RUST COMPILER
NOW SUPPOSE WE ADDED A SECOND BRUSH EXTENDING OUR BRUSH SPACE TO BE TWO DIMENSIONAL AND THIS NEW SPACE ENCODES BOTH BRUSHES AND THUS APPEARANCE OUR CANVAS WOULD HAVE
NOW THAT I'M RIDING RUST Y
NOW THAT WE HAVE BEHAVIORS DEFINED LET'S EXAMINE THE OLDER REVISION OF THE SPACESHIP AND ENEMY COMPONENTS
NOW THAT WE HAVE BRIEFLY EXPLAINED COMPONENT STORAGES WE CAN QUICKLY GO OVER THE SYSTEM PART OF ECS
NOW THAT WE HAVE COVERED ALL THIS WHAT IS THE CONCLUSION
NOW THE FIRST THING WE DO INSIDE OUR INTERRUPT SERVICE ROUTINE NEEDS TO BE SAVE THOSE WORKING REGISTERS THAT WOULD OTHERWISE BE SAVED BY THE CALLER
NOW THE SENSOR
NOW THIS IS A BIT CONFUSING SO WE'LL BE MORE SPECIFIC ABOUT THIS
NOW THIS IS CURIOUS
NOW THIS WILL PRODUCE MORE CONTEXTUAL LOGS LIKE THIS
NOW TO CARLO TO EXPLAIN HOW THE COMPONENTS ALLOW FOR MORE DESIGNABLE SYSTEMS
NOW TO CHANGE TONE A LITTLE BIT
NOW TWO PROBLEMS FOR CENTRALIZED SCHEDULE
NOW WE ARE MAKING PROGRESS
NOW WE SORT OF GENERALLY PROBABLY KNOW WHAT THAT MEANS IN TERMS OF MEMORY PROCESSING POWER AND SO FORTH
NOW WE WANT TO INTRODUCE STUDENTS TO ABSTRACTION
NOW WE WILL SEE AN EXAMPLE
NOW WE'RE DEPARTING A BIT FROM OUR DESK METAPHOR EARLIER
NOW WE'RE GONNA TRY TO LOOK AT HOW TO FIX OUR PROBLEMS
NOW WHAT WE WOULD REALLY LIKE THOUGH IS A RUST PROLOG BECAUSE THEN WE COULD HAVE A NICE CLEAN RUST FFI AND EVERYTHING WOULD BE BEAUTIFUL AND PERFECT
NOW YOU CAN RUN THIS CODE AND IT WILL RUN
NUMBERS BETWEEN 10 9 TAKE 2 BYTES AND SO ON
OBVIOUSLY THERE'S STILL WORK TO BE DONE IN THE RUST ECOSYSTEM AROUND RUST ERROR MESSAGES EVEN AROUND RUST C
OBVIOUSLY WE'RE AT RUSTFEST SO WE'VE ALL BOUGHT INTO RUST BUT THE QUESTION REMAINS IF WE CAN DO SECRET INVARIANT PROGRAMMING WITH ASSEMBLY WHY DO WE NEED TO DO IT IN RUST AT ALL
OCCASIONALLY I CONTRIBUTE TO THE RUST COMPILER PROJECT
OCHRE HIGHLY PORTABLE GPU ACCELERATED VECTOR GRAPHICS
OCHRE IS TRYING TO STRIKE A BALANCE ON THIS TRADEOFF
OF COURSE ALWAYS
OF COURSE HAVING SOMETHING LIKE A HEALTH COMPONENT ATTACHED TO AN ENTITY DOESN'T DO MUCH ON ITS OWN
OF COURSE I AM NOT REFERRING TO THIS KIND OF OXIDIZED KIND OF RUST WHICH IS GENERALLY NOT VERY DESIRABLE IN METAL FABRICATION
OF COURSE IF SOMEBODY HAD ALL THREE OF THESE ASPECTS THEY PROBABLY ALREADY HAVE TOUCHED RUST A LITTLE BUT BUT WE HAVE FOUND MANY ENGINEERS FROM OTHER LANGUAGES HAVE BEEN VERY VERY SUCCESSFUL USING RUST IN THE DEVELOPMENT OF ENTERPRISE SOFTWARE WITH US AND IT WAS BECAUSE OF THEIR STRENGTHS IN ONE OR MORE OF THESE AREAS
OF COURSE SETTING UP A NEW PROJECT IS ALSO AN IMPORTANT SKILL BUT THE FIRST IMPRESSION TO SHOW THAT THIS WHOLE THING IS NOT REALLY THAT COMPLICATED IS ALSO IMPORTANT I THINK
OF COURSE THE THREE MAJOR OPERATING SYSTEMS
OF COURSE THIS IS A BUG
OF COURSE YOU CAN ALSO PLAY WITH THIS CODE WHEN AND WHAT I THINK IT BUT WHAT IF WE MAKE IT SIMPLER BY RUNNING EXAMPLES IN THE BROWSER ON THE SAME PAGE AND SHOWING THE OUTPUT BESIDES THE CODE
OF COURSE YOU HAVE ONE EXAMPLE HERE THAT WE'LL LOOK AT MUTABILITY
OF HANDLING THIS
OF KEEPING SECRETS IN A TYPE
OF LIKE MY CODE DOESN'T WORK
OF NICELY WITH ERRORS TO DEAL
OF SOME OPTIMIZATION
OF THIS IS A LITTLE BIT OF I SUPPOSE AN EGREGIOUS EXAMPLE
OFFER MULTIPLE VARIANT OF THEIR LIBRARIES
OFTEN A COMMA AN OR A CLOSED BRACKET
OFTEN YOU FIND THERE EXAMPLE CODE ONLINE EVEN IF YOU DON'T WANT TO BUY THE BOOK
OH MAN THOSE ARE GREAT
OH NO WE'RE GOOD
OH WOULD YOU
OK
OKAY
OKAY OWNERSHIP IS NOT WORKING
OKAY SO FIRST OF ALL LET'S TAKE A STEP BACK AND TAKE A LOOK AT WHICH TYPES WE NEED TO DESCRIBE NETWORK PROTOCOLS
ON 15 WE CLEAR INTERRUPTS SO THAT WE CAN PERFORM OUR PUSHING OF THE FRAME POINTER WITHOUT BEING INTERRUPTED
ON A SLOW GPU
ON AVR THE ERROR TYPE USED FOR THIS TRAIT IS INFALLIBLE IT'S VOID
ON HOW TO BEQUEATH
ON MOST COMPUTERS THE STACK BEGINS AT THE VERY TOP OF THE MEMORY
ON SOCIAL MEDIA GENERALLYAT COUCHAND
ON THAT FORUM ON ONE POST OR ANOTHER
ON THE LEFT IS THE FRONT END WHICH IS DESIGNED TO OPTIMALY PRESENT DATA
ON THE OTHER HAND THE OPERATION WHICH I WILL CALL PAINTING DETERMINING INSIDE AND OUTSIDE OF THE SHAPE LIKE THIS DOESN'T COME NATURALLY TO GPUS SINCE THEY KIND OF ONLY NATIVELY SPEAK IN TRIANGLES
ON THE OTHER HAND THIS MAKES IT HARDER FOR US AND PRACTICALLY IMPOSSIBLE TO RUN EXAMPLES FROM CODEBASES OR EVEN FROM PUBLIC CRATES AND IT MAKES IT HARDER FOR US TO MENTOR AND EDUCATE PEOPLE THROUGH EXAMPLES
ON THE RIGHT HERE WE SEE A WELDER
ON THE SECOND ROW WE HAVE THE TAG BIT 1 FOLLOWED BY 4 BITS ALLOWING US TO SCORE THE 16 LEAST LIKELY VALUES
ON THE THERE IS NO OS WHICH MEANS WE NEED TO DO IT OURSELVES AND TO INDICATE TO THE COMPILER THAT WE ARE GOING TO WORK WITH A NO STD AND NO NAME
ON THE TRACE EVENTS THAT ARE HAPPENING INSIDE SPANS DIAMETER ARE ESSENTIALLY FUNCTION SPANS
ON THIS SLIDE YOU CAN SEE THE REQUEST DOCUMENTATION AGAIN AND IT ENCODES PARAMETERS AS HTTP FORM DATA AND AS YOU LOOK AT THIS CODE IN THE EDITOR YOU CAN SEE WHAT RESULT THIS OR THAT FUNCTION RETURNS WITH YOUR CHOSEN HINTS BECAUSE THIS COMPILER PROVIDES US WITH INFORMATION ABOUT THE FUNCTION NAMES AND TYPES THAT ARE USED THERE AND ALL THE KINDS OF EXPRESSIONS AND IT IS REALLY STRAIGHTFORWARD WORK WITH CODE AS DATA BECAUSE ALL EXPRESSIONS ARE ACTUALLY VARIANTS OF ONE LARGE SO YOU CAN USE PATTERN MATCHING TO WORK WITH THIS ENUM AS YOU NORMALLY WOULD DO WITH RUST
ONCE COVID STARTED I THOUGHT I WOULD SHARE MY LEARNINGS SO IT WOULD BE EASIER FOR OTHER FOLKS
ONCE I HAD THE ROUGHEST IDEA ABOUT WHAT COPY TYPE WAS
ONCE THE DESIGN IS COMPLETE WE NEED TO GO PURCHASE THE RAW MATERIALS
ONCE THE MATERIALS ARE ON HAND THEN WE NEED TO MAKE SURE WE UTILIZE THESE EXPENSIVE RESOURCES THE MANUFACTURING EQUIPMENT AND SCHEDULING WORKERS AND THE MACHINES TO OPTIMALLY PLAN THE MANUFACTURING SYSTEM
ONCE WE HAVE WRITTEN PARSERS FOR ALL OF THE VARIANTS WE CAN WRITE THE RUST TYPE DEFINITION AND PARSER COMBINATOR FOR THE PARENT NODES TCP OPTION AND TCP THEN OPTIONS
ONCE YOU DO THAT THE PROGRAM IS RUNNING UNTIL THE 8TH LINE AND THEN IT BREAK THE 8TH LINE AND ESSENTIALLY WE CAN PRINT HERE AND IT IS THREE
ONCE YOU GET TO TOOL YOU CAN USE IT IN MULTIPLE WAYS
ONCE YOU HAVE DONE IT IT GETS EASIER QUITE QUICKLY
ONCE YOU HAVE THIS CODE WITH THESE TYPES OF ANNOTATIONS AND YOU RUN CARGO DOCS YOU GET THIS OUTPUT
ONCE YOU HAVE THOSE TESTS EVERY TEST IS ATTRIBUTED SO WHENEVER YOU RUN CARGO TEST IT RECOGNIZES FUNCTIONS THAT ARE TEST AND RUNS THEM AS A BINARY AND OUTPUTS THE RESULTS
ONCE YOU USE THAT LIBRARY AS A DEPENDENCY AND BINARY PROJECT THEY WILL USE THAT FUNCTION TO SET THE LOG IMPLEMENTATION WHICH IS ALREADY LIKE THAT
ONCE YOU'VE GOTTEN THE KNACK OF THE CHECKER THINGS GO A LOT FASTER BUT THEY'RE STILL WRITER THAN WRITING PROLOG BECAUSE IT'S A LOWER LEVEL LANGUAGE WHICH IS WHY WE USE IT BUT IT'S ALSO WHY WE DON'T ALWAYS USE IT
ONE ALTERNATE METHOD OF STORING A STRING AND OTHER VARIABLE LENGTH DATA IS TO PREFIX THE DATA WITH ITS LENGTH
ONE INTERESTING GREAT USE IS WE HAVE A UNIFIED RA OPERATORS
ONE IS IT IS A SINGLE POINT
ONE IS STORAGE LAYER
ONE IS TEACHING PROGRAMMING FROM THE MACHINE UP AND THE OTHER FROM PROGRAMMING CONCEPTS DOWN
ONE LANGUAGE SERVER CAN BE USED WITH MANY OTHER IDES
ONE OF MY FAVORITE FEATURES IN RUST IS THE COMPILER FEATURE FLEX WHICH ALLOWS YOU TO EFFECT THE COMPILATION ESSENTIALLY
ONE OF THE KEY SIMILARITIES BETWEEN THESE PROJECTS IS THAT BOTH OF THEM HEAVILY RELY ON PERFORMING SOME KIND OF SEARCH
ONE OF THE MOST IMPORTANT PARTS OF TRYING TO REVIVE THE SPACE SHOOTER PROJECT WAS TO ESTABLISH A WORKFLOW FOR THE BOTH OF US
ONE OF THE SPECIAL REGISTERS
ONE OF THE THINGS THAT NEEDS TO HAPPEN ON THE RUST SIDE AND ON THE LLVM SIDE WE ARE GOING TO HAVE TO EVENTUALLY DO SOME IMPLEMENTATION WORK
ONE OF THE THINGS THOUGH THAT WE RAN INTO WAS THE UNEXPECTED BONUS AND WE KIND OF KNEW THIS WAS HERE BUT ARE AMAZINGLY IMPRESSED WITH IT
ONE OF THE UNO AND THE NANO IS TO MAKE IT IT HAS A GENERAL PURPOSE INPUT AND OUTPUT PINS THOSE LITTLE HOLES AND ALL THE PROTOCOLS
ONE OF THEM IS A RESET PIN
ONE OTHER IMPORTANT CONCEPT BEFORE WE DIG IN HERE
ONE OTHER THING I WANTED TO END MY TALK IS WE COVERED A LOT OF THINGS SO IF YOU HAVE NOT UNDERSTOOD ANYTHING PLEASE DON'T FEEL INTIMIDATED
ONE OTHER THING TO KEEP IN MIND IS THAT AVR INTERRUPT SERVICE ROUTINES ARE EXPLICITLY EXPERIMENTAL
ONE SECOND
ONE THAT DOESN'T FEATURE IN TCP IS THE FUNCTION DATA TYPE
ONE THING I STILL HAVEN'T GOTTEN TO IS FIGURING OUT A GOOD STRATEGY FOR SEARCHING FOR A COLOUR SOLUTION
ONE THING I WANT TO MENTION HERE IS THE HEIGHT IS A LITTLE HIGH
ONE THING I WANT TO SAY IS TENSORBASE IS A ONE PERSON PROJECT OVER SEVERAL MONTHS
ONE THING WE MEAN BY 0 COST ABSTRACTIONS ARE ABSTRACTIONS THAT DON'T INTRODUCE UNNECESSARILY SERIALIZATION FORMATS
ONE THIRD OPTION THAT I'VE RECENTLY STARTED LOOKING AT FOR DEBUGGING IN AN EMBEDDED CONTEXT IS SIMULATING
ONE TYPE OF VARIANT USES THE CHANNELS
ONE TYPE THAT IMPLEMENTS THE TEXT TRAIT THIS STRING SO YOU CAN PARSE A GRAPHQL QUERY INTO STRING AS THE TEXT TYPE AND BECAUSE VALUE WILL OWN ITS BETA IT ALLOWS YOU TO MANIPULATE THE GRAPHQL AND WRITE IT BACK OUT
ONE WAS THAT THE SPACESHIP AND ENEMY COMPONENT HAD A LOT OF REDUNDANT DATA
ONE WAY IS TO HAVE THE PLAYER TAG ATTACHED TO THE ENTITY TO DIFFERENTIATE A HEALTH COMPONENT ASSOCIATED WITH THE PLAYER ENTITY FROM THE OTHERS
ONE WHEN ENCODING A VALUE THE LENGTH IS NOT KNOWN UP FRONT AND MAY INCREASE AND THAT MEANS YOU CAN'T RELY ON RESIZING THE BUFFER UP FRONT BUT INSTEAD MUST CONTINUALLY CHECK THIS BUFFER SIZE WHEN CODING THIS VALUE OR OVER ALLOCATE BY TWICE AS MUCH
ONE WORD THAT KEPT KIND OF CROPPING UP IN MY HEAD WHILE I WAS LOOKING THROUGH THIS STUFF AND DIGGING THROUGH RUSTC
ONLY ONCE YOU'VE GOT THEM YOU GO INTO DETAILS
ONLY THEN DID I LOOK AT MY APPLICATION DOMAIN
OPEN IS NOT AVAILABLE
OPENGL LOOKS PROMISING
OPTIMIZATIONS CODE GENERATION FOR THE MACHINE CODE AND SO FORTH
OR A WEB CONTEXT
OR ADDITIONAL MESSAGE
OR AN ORDER OF MAGNITUDE WORSE THAN THE SIMPLE YES OR NO ANSWER THAT RUST GIVES US
OR DIFFERENT WAYS IN WHICH DIAGNOSTICS ARE SURFACED WHEN I WAS DOING RESEARCH FOR THIS TALK ONE THING THAT KIND OF KEPT
OR DIG IN
OR DO YOU THINK WE SHOULD INTRODUCE THE THINGS FIRST THROUGH A MORE BASIC LANGUAGE LIKE GO TO EASE INTO RESOURCE MANAGEMENT
OR ENGINEERS AS WELL
OR EVEN TO MOVE TO AN EXISTING APPLICATION AND SEE HOW THEY ARE WORKING WITH ON RUST SOURCE CODE
OR FOLDED INTO THE COMPILER ITSELF
OR HAS IT BEEN BASICALLY POSITIVE
OR I CAN ADD A NEW KEY WHILE YOU PAIR HEY RUSTFEST AND YOU CAN SEE THERE IS A NEW KEY NOW
OR IF A NEW ARCHITECTURE PROBLEM ARISES AS A RESULT OF FIXING THAT ONE ISSUE
OR IF THERE IS LIKE OBVIOUS FLAWS IN THE
OR IF YOU WANT TO TRY IT YOURSELF IT IS SUPER COOL BECAUSE WHAT YOU HAVE TO LEARN IS ACTUALLY YOU HAVE TO READ YOUR PLATFORM SPECIFICATION ABOUT HOW WOULD THAT FOREIGN FUNCTION WORK
OR IS IT A QUESTION OF CULTURE
OR IS IT A QUESTION OF TECHNOLOGY
OR IS THIS ALSO MUCH TO LEARN
OR ISR IS EXPERIMENTAL
OR IT COULD BE A WARNING OR COULD BE A LINT FOR EXAMPLE
OR MAYBE A MAGICAL LUTE
OR MAYBE IT DOES
OR MAYBE THEY JUST ABANDONED THEIR EFFORTS AND SORT OF KEEP USING PYTHON
OR OUR FRAME POINTER BEING RESTORED LATER THAN IT SHOULD
OR PERHAPS FINISHED COUNTING TO 256
OR PERHAPS WE'VE RECEIVED A BYTE ON A NETWORK INTERFACE
OR THE ERROR CASE OF THE UNWRAP NEVER GETS CALLED
OR THE TRAIT'S MISSING
OR WE DIDN'T CORRECTLY WRITE IT IN THIS CASE
OR WITHOUT STARING AT A WALL OF COMPILER ERRORS THAT YOU DON'T REALLY UNDERSTAND BECAUSE YOU DECIDED TO USE THE MOST ADVANCED
OR YOU CAN ALSO USE THE PYTHON CODE IN RUST AS WELL
OR YOU KNOW YEAH
OTHER CONTEXT
OTHER MESSAGES CAN TUNE INTO THIS CHANNEL BY SETTING UP AN EVENT READER TO LOOK FOR EVENTS OF A CERTAIN TYPE
OTHER SORTS OF ERROR MESSAGES CAN CROP UP
OTHER SORTS OF ERROR MESSAGES THAT CAN CROP UP OR I SHOULD SAY DIFFERENT PHASES OF THE COMPILATION PROCESS WHERE OF COURSE OTHER ERRORS
OUR COMPUTER SYSTEMS ARE COMPRISED OF MANY FORMATS NESTED
OUR CORE IS FORCED TO MAKE QUERIES CAN CANNOT BE OPTIMIZED FASTEST HERE
OUR EARLIER PROTOTYPE IS ACTUALLY IN JAVA
OUR EYES CAN KIND OF PICK UP ON SOME KIND OF CLUSTERING OF THE DOTS
OUR FIRST ARGUMENT FOR ALL OUR PARSER FUNCTIONS IS AN INPUT TUPLE
OUR FIRST AUTOMATICALLY GENERATED LIBRARIES WOULD BE RAINFALLS FILES BECAUSE WE WANTED RESULTING IS HAVE A GOOD LEVEL OF TYPE SAFETY
OUR GENERATED PARSER LIBRARIES ARE NOT ONLY A MANUAL EXPLAINING HOW THIS DATA SHOULD BE PARSED THEY ALSO ALLOW PROTOCOL DEVELOPERS TO BUILD THE STRUCT WITH EXTRACTED VALUES WITH A SINGLE FUNCTION CALL
OUR MAIN GUIDING PRINCIPLE IS THAT WHILE SOME IDEAS ARE CERTAINLY BAD ALL IDEAS ARE WORTH SHARING
OUR OUTPUTS ARE NON SPECIFIC RESULT TYPE CONTAINING THE REMAINING BYTES LEFT TO BE PARSED AN UPDATED BIT COUNTER INSTANTIATED WITH THE CORRECT VALUE READ FROM THE BYTE ARRAY
OUR PARSERS WORK AT THE BIT LEVEL SO THE SECOND TUPLE ELEMENT IS AN INTEGER WHICH TRACKS HOW MANY BITS WE'VE READ IN THE CURRENT BYTE
OUR PROXY IS DOMAIN RUST AND WE USE RUST WERE OTHER REASONS
OUR SECOND ARGUMENT IS A MUTABLE BORROW FROM THE CONTEXT INSTANCE SINCE WE MIGHT WANT TO UPDATE THIS AW WELL AS WE
OUR SOFTWARE IS A POLYGLOT HOUSE SO WE HAVE CLIENTS WRITTEN IN JAVASCRIPT AND IN PYTHON
OUR SPECIAL AND GENERAL REGISTERS AND WE CAN RETURN
OUR VERTEX CONSISTS OF ONLY A POSITION WITH THREE THIRTY TWO BIT FLOAT COORDINATES AND A COLOR HAVING 3 UA CHANNELS
OVERALL PEOPLE HAVE BEEN PROVIDING ME WITH TECHNICAL CONSULTANCY AS WELL AS PSYCHOLOGICAL SUPPORT SINCE THE START OF MY ADVENTURES IN RUST
OVERHEAD IS A LITTLE HIGH
PACKETS AND PROTOCOL UNITS AS A WHOLE CAN BE CONSIDERED AS STRUCTURE LIKE TYPES GIVEN THEY CONTAIN FIELD TYPE AS CONSTITUENT TYPE MEMBERS
PARSERS CAN BE DIFFICULT TO WRITE MANUALLY AND ARE PRONE TO CONTAINING ERRORS
PART OF THE REASON I REACHED OUT TO MICAH TO COLLABORATE ON THE PROJECT I KNEW SHE LIKELY HAD A LOT MORE EXPERIENCE USING THESE TOOLS THROUGH HER WORK AT MOZILLA
PARTICULARLY CUMBERSOME IS THE LINE THAT OFFSETS THE R FIELD
PARTICULARLY FOR INSTANCE ARM OBVIOUSLY
PARTLY THIS IS DUE TO THE LEARNING CURVE OF THOROUGH CHECKING SEMANTICS MEANING THERE IS A DIFFICULTY IN GETTING OUR DEVELOPERS TO UNDERSTAND HOW THIS STUFF WORKS SO THAT TAKES SOME TIME
PARTS OF TYPESCRIPT ARE PRETTY NEAT BUT RATHER SHOW YOU THE COMPLEXITY A MEMORY MANAGED PROGRAM ADDS TO THE PROBLEM THAT WASN'T THERE TO START
PEOPLE REALLY CARE ABOUT THAT IN THE CORE TEAM
PEOPLE SAY YES PERFORMANCE MATTERS BUT SAFETY'S FIRST
PEOPLE SHOULD TRY RAYON IS DEFINITELY ONE THING
PERFORMANCE CONSTRAINTS
PERFORMING A FUNCTION IS A SPAN
PERHAPS A PILE OF FILE FOLDERS ON OUR DESK
PERHAPS I'M WORKING ON A CLIENT
PERHAPS IF A BRUSHSTROKE IS PLACED COMPLETELY PERPENDICULAR IT MIGHT ACTUALLY BE A VERY GOOD SOLUTION AND TO THE PIXEL AND EDGE DIFFERENCE IS WHAT MATTERS
PERHAPS MODERN MOBILE
PERHAPS THE COMPUTER FINISHED COUNTING TO 20
PERHAPS THE GREATEST ABSTRACTION OF ALL TIME IS THE FUNCTION CALL
PERHAPS YOU THINK IN HIGH LEVEL TASKS LIKE SERVING AN HTTP TASK
PERSONALLY I CAN'T
PERSONALLY I HAVEN'T DONE A LOT OF CYTHON MYSELF
PHEW
PIECING TOGETHER RUST IT IS MORE THAN JUST WRITING CODE
PLEASE ALSO FOR THE PEOPLE WATCHING THEIR LIVE STREAMS STICK AROUND FOR THAT
PLEASE GO FOR IT
PLEASE NOTE THAT IT IS VERY IMPORTANT TO CHOOSE THEM RIGHT THE PINS BECAUSE THEY'RE HARD WIRED ACTUALLY SO THIS IS MY BIG ERROR NUMBER THREE SO TIMER TWO THAT I'M USING IT HARD WIRED TO WIN D3
PLEASE PASS THE FLAG TO DISABLE THIS ISOLATION
POINTER TO ALLOCATION WAS DE REFERENCED AFTER THIS ALLOCATION GOT FREED
POTENTIALLY
PREDICT WHAT THE DATA WILL BE AND ASSIGN REPRESENTATIONS TO THE VALUES SO IF THE PREDICTION IS ACCURATE FEW BITS CAN BE USED TO REPRESENT THE VALUE
PRETTY MUCH USE VECTOR GRAPHICS AT THIS POINT
PREVIOUSLY I WAS AN INTERN AT CNCF
PREVIOUSLY THERE WAS A TOOL IN RUST DOING THE SAME JOB BUT IT WAS SLOW ESPECIALLY FOR BIGGER ONES
PRIMARILY HIRING FOR RUST NEW ENGINEERING TRAINING AND HOW TO MAINTAIN A GOOD COMMUNITY WITHIN THE DEVELOPMENT AND FINALLY A BIT ABOUT THE COMMUNITY WORK
PROBABLY THE HARDEST PART OF THIS WHEN YOU WRITE CODE THAT RUNS ON THE GPU YOU USE WHAT'S CALLED A SHADING LANGUAGE
PROCEDURAL ARTS' DISTINGUISHING FEATURE IS THAT IT IS EXECUTED BY A COMPUTER FOLLOWING A SET OF DESIGN PROCEDURES DESIGNED IN CODE THAT'S WHY IT IS PROCEDURAL
PROCEDURE MACRO WHICH IS GREAT FOR LEARNING RUST BUT IT IS ALL IN PROBLEMS
PROGRAMMER'S WAY OF SAYING OKAY COMPILER GET OUT OF MY WAY I REALLY WANT TO DO THIS
PROGRAMMERS SHOULD ONLY BE ABLE TO USE WHAT THEY NEED
PROGRAMMING WITH C I'VE NEVER LIKED AND IT'S ALWAYS BEEN FRUSTRATING
PROJECT NECROMANCY HOW TO REVIVE A DEAD RUST PROJECT
PURCHASED BY THE PLAYER AND WHEN ACQUIRED CHANGE THE RULES OF THE GAME TO BENEFIT THE PLAYER
PURCHASING MANUFACTURING AND LOGISTICS
PUSHING BACK THE PROCESS INTO THE BACKGROUND AND PUTTING THE EXPERIENCE OF THE SEARCH TO BE THE MAIN ART PIECE
PUT IN ANOTHER WAY BLOAT IN THE REPRESENTATION OF THE DATA THROTTLES THE THROUGHPUT OF INFORMATION
PYTHON'S IS ENORMOUS
QT IS A C PLUS PLUS FRAMEWORK AND IT'S RATHER BIG
QUIC BEING HIGH PROFILE AND A COMPLEX PROTOCOL I THINK
QUICK QUESTION
R HIR IS MADE FOR DATA RELATEDED OPTIMIZATIONS WHICH CANNOT BE HANDLED BY LOW LEVELS COMPILERS
RACKET DOES HAVE MATCH EXPRESSIONS BUT THIS IS SOMETHING THAT WASN'T INTRODUCED DURING FUNDIES�1
RATHER THAN EDGE PIXELS AND SOLID SPANS I HAVE 8X8 EDGE TILES AND THEN SOLID 8XN SPANS IN THE MIDDLE
RATHER THAN KIND OF TRYING TO TAKE OVER AND INSIST ON THINGS BEING DONE A CERTAIN WAY
RAYON WAS A GREAT THING TO TRY
READ IN OUR FRAME POINTER
READ THE EXAMPLE CODE AND WONDER OKAY WHAT ARE THEY DOING HERE
REAL WORLD EXAMPLE FOR A BUTTON HANDLING LIBRARY
REALLY I THINK IT IS JUST A QUESTION OF INCREASING THE PRIORITY OF
RECALL THAT WE STATED THAT EACH MOVE IS LIKELY TO BE NEAR THE PREVIOUS MOVE
REFACTOR A BLOATED COMPONENT INTO SMALLER COMPONENTS
REFACTOR IT THINK OKAY WHICH ADDITIONAL FEATURE COULD I
REFERENCE TO STIR ALSO IMPLEMENTS TEXT
RELATED TO THAT IS THE SECOND IDEA PRACTICE
RELATED WORKS COMPARE SOME PROJECTS
REMEMBER EARLIER WHEN I MENTIONED THAT I THINK OF THESE BASICS TYPES AND PARSERS AS BUILDING BLOCKS
REMEMBER THAT BECAUSE THE CHOICE OF SERIALIZATION FORMAT IS A DECIDING FACTOR IN HOW YOU CAN APPROACH THE PROBLEM THAT THE ADVANTAGE RUST GIVES US OF BEING ABLE TO CHOOSE HOW DATA IS REPRESENTED CARRIES FORWARD INTO EVERY PROBLEM NOT JUST WRITING VERTEX BUFFERS
RESOURCES FOR THIS PROJECT CAN BE FOUND AT THESE LINKS
RESOURCES IN AMETHYST ARE CONTAINERS OF DATA NOT ASSOCIATED WITH AN ENTITY
RFC SECRET TYPES IN RUST
RGB IS A WAY THAT WE USE OFTEN IN WEB DEVELOPMENT AND LET'S SAY EIGHT BIT COLORS CAN BE USED
RIGHT
RIGHT NOW CARGO IS THE EASIEST WAY TO RUN RUST CODE
RIGHT NOW I'M DIRECTLY TARGETS FROM THE TARGET IMAGE
RIGHT NOW THE INTRODUCTORY COURSES ARE TAUGHT IN RACKET AND JAVA AND YOU DON'T REALLY HAVE TO WORK ABOUT THE STACK VERSUS THE HEAP IN THERE
RIGHT NOW THE MOST IMPORTANT CONTENT IS HELPING THEM MAKE CONTRIBUTIONS TO THE PROJECT
RIGHT OFF THE BAT WE HAVE NO IMPLICIT CONVERSIONS BETWEEN PRIMITIVE TYPES
RISKY INPUTS NO NEED TO BE BRAVE
RUNNING ON AN AVR DEVICE
RUST ACTUALLY HAS MONADS AND THIS IS NOT THE PROPER WAY TO DEFINE THEM
RUST AS A FOUNDATION IN A POLYGLOT DEVELOPMENT ENVIRONMENT
RUST C SAYS YOU FORGOT THE TURBOFISH
RUST CAN NO LONGER COMPILE THAT PROGRAM CORRECTLY SO WHAT THIS MEANS IS THAT IN THE BEST CASE YOUR PROGRAM MIGHT NOT RUN MAYBE IT PROS RECEIVES THEM INTO A FOLDER MEMORY OUT OF BOUNDS ERROR OR SOMETHING LIKE THAT
RUST CAN PRODUCE VERY FAST PROGRAMS
RUST DOCUMENTATION IS ONE OF MY FAVORITE PARTS BECAUSE THERE IS A STANDARD WAY ENFORCED ON HOW TO WRITE DOCUMENTATION SO IT IS COMMON ACROSS MANY LIBRARIES
RUST DOESN'T HAVE A ONE TO ONE EQUIVALENT OF THIS SO WE'RE GOING TO BREAK IT UP INTO TWO DIFFERENT PARTS
RUST ECOSYSTEM IS SMALLER THAN THAT OF PYTHON OF COURSE
RUST FEATURE
RUST FOR ARTISTS ART FOR RUSTACEANS
RUST FOR EXAMPLE IS RUST BY EXAMPLE IS QUITE NICE IN TERMS OF BOOK
RUST FOR FRESHMEN
RUST FOR SAFER PROTOCOL DEVELOPMENT
RUST GIVES YOU THESE TOOLS IN ABUNDANCE
RUST HAD THIS KIND OF INCREDIBLE ASPECT TO IT WHICH IS THIS ABILITY TO AVOID MEMORY PROBLEMS WHILST STILL BEING EXTREMELY LOW LEVEL PROGRAMMING LANGUAGE
RUST HAS A GREAT INSTALLATION EXPERIENCE
RUST HAS THIS NOTION OF THERE BEING A LIT OF A LEARNING CURVE ASSOCIATED WITH IT
RUST HAS THREE DIFFERENT CYCLES STABLE BETA AND NIGHTLY AND THESE HAVE RELEASES
RUST HAS TO EXPOSE SOME OF THESE COMPLEXITIES
RUST INTERNALLY USES WHENEVER YOU RUN CARGO IT CHOOSES THE DEFAULT TOOL CHAIN
RUST IS EXTREMELY POWERFUL
RUST IS GREAT
RUST IS THE ONLY MEMORY SAFE LANGUAGE THAT I AM AWARE OF THAT DOES
RUST ISN'T HIDING THE FACT THAT OUR DATA IS REPRESENTED AS BYTES UNDER THE HOOD AND HAS GIVEN US CONTROL OF THE REPRESENTATION
RUST PACKAGE MANAGEMENT IS A PRETTY FULL FLEDGED PACKAGE TOOL BY CARGO PACKAGE MANAGEMENT IS TALKING ABOUT CARGO
RUST TAKES THIS UP A NOTCH BECAUSE THERE IS A THIRD TYPE FROM THE STANDARD LIBRARY THAT IMPLEMENTS TEXT
RUST WILL GET EASIER
RUST WITH HUMILITY IN THREE EASY IDEAS
RUST'S ERROR MESSAGES ARE BETTER THAN ANY OTHER LANGUAGE'S ERROR MESSAGES
RUST'S ERROR MESSAGES ARE ONE OF THE
RUSTC AND THE DEVELOPERS WHO WORKED ON RUSTC THEY'RE ALL IN THAT WAY EAGER TO HELP YOU
RUSTUP IS A TOOLCHAIN MULTIPLEASURE MULTIPLEXOR
SAFE MUTABLE APPENDABLE STRINGS OR BINARY TYPES ALLOW US TO PROGRESSIVELY PUSH SERIALIZED DATA FROM EACH FORMAT INTO THE SAME BUFFER RATHER THAN SERIALIZING IN THE SEPARATE BUFFERS AND THEN COPYING EACH BUFFER INTO THE NESTING FORMAT ABOVE
SAY BYE TO YOUR NEW FRIEND
SAY PROGRAMMING LANGUAGE IS EASY MODE BECAUSE YOU HAVE WELL YOU HAVE A GARBAGE COLLECTOR YOU HAVE A REFERENCE COUNTING YOU HAVE A SYNTAX
SAY YOU GOT A PACKAGE GENERATED BY C AND WE FED IT THROUGH OUR RUST PARSERS WE COULD POTENTIALLY FIND SO IT IS WRITTEN IN OTHER LANGUAGES WE JUST NEED THE OUTPUT THAT THEY GENERATE
SCHEDULING
SEAN CHEN WANTS TO SHOW THE APPEAL
SECOND C BASED JIT COM PILATION IS LIGHTNING FAST AND IT IS MUCH FASTER THAN C PLUS PLUS AND RUST AND IT IS QUITE ENOUGH FOR OLAP
SECOND IS HIGH PERFORMANCE PROGRAMMING IN PARADIGM IN RUST
SECOND IT ALLOWS THE INTEGRATION OF CRYPTOGRAPHIC CODE WITH THE REST OF AN APPLICATION WITHOUT THE USE OF FFI
SECOND OPTIMIZER
SEE ME RIDING RUST Y
SEE YOU BOTH
SEE YOU IN THE CHAT
SEE YOU LATER
SEE YOU RIDING RUST Y
SEEING RUSTC'S EXAMPLE
SEEING THE GENETIC STUFF REALLY TRIGGERED ME
SERIALIZATION AT THIS LEVEL INCLUDES MANY WELL KNOWN FORMATS MP3 JSON AND HTTP AMONG OTHERS
SERIALIZATION FORMATS TEND TO REFLECT THE ARCHITECTURES OF THE SYSTEMS THAT USE THEM
SERIOUSLY
SHE HAD INDUSTRY PRACTICES THROUGH WORK AT MOZILLA
SHE'S ASLEEP
SHE'S MELTED INTO A PUDDLE
SHOWING MOVING GROOVING WANT TO SEE ME RIDING RUST Y
SIDE STEPPING THE ARGUMENT THAT SCHEMAS ARE NECESSARY FOR PERFORMANCE
SIMPLY BECAUSE RUST DOES IT DIFFERENTLY
SINCE A LOT OF TASKS YOU DO THE SAME OPERATION PER PIXEL
SINCE NO COMPRESSION METHOD IS ONE SIZE FITS ALL IT EVEN SPENDS SOME PERFORMANCE TRYING A NEW TECHNIQUES ON THE SAMPLE OF THE DATA FROM EACH BUFFER
SINCE THE PROBLEM MADE IT DIFFICULT TO REUSE IT MADE THE PROPERTIES SPECIFIC TO THE COMPONENT THEY WERE ASSOCIATED WITH
SINCE THEY'RE
SINCE WE ARE TALKING MAINLY ABOUT THINGS LIKE SHORT SNIPPETS OF CODE AND EXAMPLES INSTEAD OF LIKE LARGE CODEBASES IT'S POSSIBLE TO GIVE A USER A KIND OF A SLIDER TO GO BACK AND FORTH TO REALLY SEE THE EXECUTION FLOW OR THEY CAN JUST JUMP STRAIGHT TO A POINT IN TIME THAT IS INTERESTING TO THEM JUST BY CLICKING ON THE SLIDER
SINCE WE NEED TO PERFORM ITERATION IT NEEDS TO BE FAST
SINCE WE WERE BOTH LEARNING NEW THINGS AS WE REFACTORED SPACE SHOOTER WE WANTED TO WORK ON DOCUMENTATION AS A WAY TO RECORD THOUGHT PROCESSES
SINGLE POINT HAS FAILURE AND SINGLE POINT LIMITED IN SCALABILITY
SO
SO 63 ONLINE 4 THE CONSTANT 63 REFERS TO THE SPECIAL REGISTER THE STATUS REGISTER
SO A COUPLE OF
SO A LOT OF PEOPLE WANT TO KNOW HOW TO SPEED UP THEIR CODE OR GET BETTER PERFORMANCE
SO A LOT TO THINK ABOUT
SO A PLUS ON THE FUNCTION
SO ADDING
SO AGAIN I KNOW THEY GAVE A LITTLE BIT OF A RECAP FOR ME
SO AGAIN IN ANSWER TO YOUR QUESTION SORRY THE QUESTION WAS ABOUT MULTIPLE PROTOCOLS NESTED
SO AGAIN LET'S NOT DEFINE IT BASED ON ITS INTRINSIC PROPERTIES BUT RATHER USE ANOTHER SIMPLIFYING MODEL
SO AGAIN THERE IS AGAIN A FUNCTION INSIDE OF RUSTC THAT SPECIFICALLY HANDLES THIS ERROR CLASS
SO AGAIN THIS IS A TECHNICAL CONFERENCE
SO ALL ARITHMETIC HAS TO BE DONE ON INTEGERS
SO ALMOST ANY QUESTION THAT I HAVE HAS ALREADY BEEN ANSWERED ON THAT PLATFORM
SO AN ISSUE I HAVE WITH THE CURRENT LANDSCAPE OF SORT OF SCIENTIFIC COMPUTING IS THAT MOVING FROM PYTHON WHICH IS A LOT OF PEOPLE'S FIRST LANGUAGE TO SOMETHING LIKE C PLUS PLUS WHICH IS YOU KNOW SORT OF A MORE PERFORMANCE ORIENTED EXPERT LEVEL PROGRAMMING LANGUAGE THIS SHOULD BE A NATURAL STEP BECAUSE MANY POPULAR PYTHON LIBRARIES DEPEND ON C PLUS PLUS AS SORT OF A BACKEND LANGUAGE
SO ANOTHER MAGIC NUMBER THAT I WOULD LIKE TO EXPLAIN IS 58 THAT YOU WILL SEE IN THE CODE
SO ANOTHER THING THAT MAKES WRITING SCIENTIFIC CODE VERY
SO ANYTHING THAT CAN REDUCE THE AMOUNT OF TIME WE SPEND WRITING THINGS WHILE ALSO IMPROVING PERFORMANCE IT'S A HUGE WIN
SO ARE THERE SOME CONCEPTS THAT I DON'T KNOW YET
SO AS AN ENTERPRISE SOFTWARE DEVELOPMENT CORPORATION IT IS IMPORTANT THAT WE PARTICIPATE IN THE COMMUNITY AND SO WITH THE PANDEMIC HERE IN TOKYO A LOT OF THINGS STARTED SHUTDOWN IN MARCH SO IN APRIL WE STARTED AN ONLINE MEETUP CALLED SHITAMACHI RS
SO AS AN EXAMPLE IN METAL FABRICATION WE USE PAINT TO PREVENT RUSTING GIVEN THE VARIOUS PAINTS AND COLORS LET TRY TO CREATE A DATA STRUCTURE TO EXPRESS THE COLOR OF PAINT IN RUST
SO AS LONG AS I'M NOT HEARING ANYTHING JUST ASSUME
SO AS MUCH AS POSSIBLE IT'S NOT GOING TO LET YOU DO UNSAFE OPERATIONS
SO AS MY LAST WORDS LET'S AS CORPORATIONS AND ANY ENTERPRISE USER OR ANY COMMERCIAL ENTITY OR ANY DEVELOPMENT TEAM FOR THAT MATTER I THINK IT IS REALLY REALLY IMPORTANT TO SHARE REAL WORLD USE CASES OF RUST AND TO REALLY SUPPORT THE RUST OF THE COMMUNITY BECAUSE THE SUCCESS OF THE COMMUNITY GIVES BACK TO THE SUCCESS OF EVERY PROJECT THAT WE WORK ON
SO AS WE SAID PREVIOUSLY WE'RE GOING TO PUT OUR PROGRAM INTO MEMORY
SO AS YOU CAN SEE WE HAVE THE ANIMAL SHARED IMPLEMENTATION FROM EARLIER AND WE ALSO HAVE THE DOG IMPLEMENTATION FROM EARLIER
SO AT THE SAME TIME WE DON'T WANT TO DRAIN BATTERY FROM THE LAPTOP OR A MOBILE PHONE
SO AVR MAYBE TIER 3 BUT YOUR PATIENCE MAN IS LIKE GOD TIER
SO BASICALLY EVERY PROGRAM YOU HAVE IS UNSAFE IN ONE WAY OR THE OTHER EVEN IF YOU DON'T KNOW IT
SO BASICALLY I I WANTED OCHRE TO BE USABLE AS A COMPONENT RATHER THAN KIND OF TAKING OVER THE DESIGN OF YOUR PROGRAM IF YOU USE IT
SO BECAUSE OF INCREASING RESOLUTIONS AND YOU SHOULD NOTE REFRESH RATES ARE ALSO STARTING TO BECOME AN ISSUE BECAUSE 120 HERTZ 144 HERTZ MONITORS ARE STARTING TO ENTER THE MARKET
SO BEFORE WE WALK THROUGH THAT LET'S WALK THROUGH THE CORRESPONDING SEQUENCE FROM THE PROLOGUE
SO CAN YOU HEAR ME NOW
SO CONCLUSIONS INITIALLY I DECIDED ON RUST AS OUR FIRST PARSER OUTPUT LANGUAGE BECAUSE I ENJOYED RUST FOR SYSTEMS PROGRAMMING ON A PREVIOUS PROJECT
SO DEPENDENCIES BETWEEN THE MANY OTHER PACKAGES THAT I USED WERE REALLY HARD TO FIGURE OUT
SO DISABLING INTERRUPTS THAT TELLS THE
SO DOING SIMPLE THINGS ANDDOING THEM OFTEN ULTIMATELY LEADS TO MASTERING I WOULD ARGUE QUICKER THAN IF YOU TRIED TO CHALLENGE YOURSELF TOO MUCH
SO EITHER YOU'RE GOING TO HAVE TO REWRITE YOUR SHADERS FOR EACH PLATFORM OR YOU'RE GOING TO HAVE TO FIGURE OUT SOME CROSS COMPILATION SETUP WHERE YOUR BUILD SYSTEM INCLUDES A SHADER COMPILER WHICH INCREASES COMPLEXITY AND YOU HAVE TO NEGOTIATE PLATFORM SPECIFIC FEATURES WHEN YOU'RE DOING SO
SO EVAN WROTE A VERY THOROUGH AND USEFUL BLOG POST
SO FAR HEALTH AND MONEY
SO FAR IT MIGHT SEEM LIKE QUITE A REDUNDANT TRANSFORMATION
SO FAR WE HAVE DISCUSSED SOME IMPLEMENTATION DETAILS FOR THESE IDEAS BUT OVERARCHINGLY HOW DO WE ACTUALLY MAKE IT WORK
SO FIRST
SO FIRST I'M GONNA TRY TO ANSWER THE QUESTION WHY I'M MAKING A VECTOR GRAPHICS RENDER IN THE FIRST PLACE
SO FIRST OF ALL I WANT TO SAY WHAT I WANT TO GIVE THIS TALK WHAT I THINK IS IMPORTANT SOMEHOW
SO FIRST OF ALL IT'S JUST MORE SPACE EFFICIENT TO STORE THE VECTOR FORM OF SOMETHING THAN THE IMAGE FORM
SO FIRST OF ALL IT'S UNLIKELY THAT YOU WILL SUCCEED IN TWEAKING THE CHECKER GOING FORWARD ON UNSAFE CODE AND IT MAKES THINGS HARDER
SO FIRST OF ALL SIMPLE CODE IS OKAY
SO FIRST OF ALL THE RUST COMPILER ITSELF CANNOT BE BUILT INTO THE WEBASSEMBLY MODEL YET SO THIS REQUIRES US TO HAVE A COMPILER SERVICE THAT WILL BUILD ARBITRARY RUST CODE INTO THE WEBASSEMBLY FOR EVERYONE
SO FIRST QUESTION IS WHY IS ITEM AND SPACESHIP COLLISION A SEPARATE SYSTEM FROM SPACESHIP AND ENEMY COLLISION
SO FIRST WE'LL LOOK AT THE PROCESSER
SO FIRST WE'RE GOING TO READ IN FROM 61 AND 62
SO FIRST WHAT IT DOES IS THAT IT CHECKS IF THIS CONDITIONAL VALUE IS ACTUALLY ZERO SO IS IT FALSE
SO FIRST WHY DID WE LOOK INTO RUST IN THE FIRST PLACE
SO FOR COMPLEX SCENES LIKE THE THE THERE'S A TIGER SCENE THAT THIS IS A CLIPPING OF
SO FOR EXAMPLE HERE WE HAVE A MODULE WITH THE FUNCTION CALLED IT WORKS
SO FOR EXAMPLE IF YOU HAVE A PROGRAM THAT IS SUPPOSED TO RUN IN WINDOWS WITH YOU YOU DON'T HAVE A WINDOWS MACHINE YOU CAN USE MIRI TO INTERPRET THAT PROGRAM AS IF IT WERE A WINDOWS PROGRAM
SO FOR EXAMPLE LIKE YOU WERE SAYING CONCURRENCY THREADING SHOULD BE IN ADVANCED COURSES
SO FOR EXAMPLE ON THIS SLIDE YOU CAN SEE SOME CODE FROM THE DOCUMENTATION OF AN HTTP CLIENT LIBRARY CALLED REQUEST
SO FOR EXAMPLE YOU HAVE A POINTER BETWEEN I DON'T KNOW YOU USE 64S YOU USE SIXTEEN BITS INSTEAD OF SIXTY FOUR BITS YOU WILL END UP READING LIKE IN BETWEEN VALUES THAT'S AN UNALIGNED POINTER
SO FOR INSTANCE MY ATTINY 85 THAT I LOVE HAS 8 PINS
SO FOR ME THOUGH RUST IS EXCITING BECAUSE IT REALLY ALIGNS WITH MY GOALS AS A RESEARCHER
SO FOR THE NEXT PART I WILL GIVE THE FLOOR TO DIANE AND SHE WILL BE TALKING HOW WE CAN USE SECRET TYPES IN RUST TO MAKE OUR LIVES A LITTLE BIT BETTER
SO FOR THESE REASONS THERE IS SOMETHING ELSE AND YOU CAN ALSO OFFSET THOSE POINTERS USING INTEGERS
SO FOR THINGS WRITTEN IN FORTRAN AND JULIA I THINK ALL OF THESE LANGUAGES ARE VERY IMPORTANT AND THEY DEFINITELY HAVE THEIR PLACE
SO FOR US TO TRULY HAVE SECRET INDEPENDENT RUNTIMES WE NEED TO ELIMINATE THE PROBLEMATIC INSTRUCTIONS
SO HAVING THAT KIND OF REPO EXPERIENCE THAT REALLY DOES HELP DEVELOPMENT
SO HAVING THESE THINGS SORT OF CAUGHT UP FRONT IS REALLY IMPORTANT BECAUSE THE MORE THINGS THAT YOU CATCH OR COMPILE TIME THE LESS YOU HAVE TO WORRY ABOUT AT RUNTIME
SO HERE I HAVE THE
SO HERE WE HAVE A BREAD BOARD WITH A ATTINY 85 MICROCONTROLLER
SO HERE WE HAVE A CUSTOM DATA STRUCTURE CALLED COOL DATA
SO HERE WE HAVE ANOTHER USER OF OUR LIBRARY
SO HERE WE HAVE SOME DOCUMENTATION TESTS WHERE IT'S SORT OF THE SAME EXAMPLE AS BEFORE
SO HERE WE'LL DEFINE THIS OUTPUT BY HOW WE USE IT
SO HI YOU'RE LIVE WITH US NOW
SO HOPEFULLY I'VE CONVINCED YOU THAT A GPU ACCELERATED VECTOR RENDERER IS A DESIRABLE THING TO HAVE FOR A UI
SO HOW DO WE KNOW HOW TO DO THAT
SO HOW TO USE MIRI
SO I ALWAYS WENT THROUGH THIS PLANNING DOING PHASE WHICH ALLOWED ME TO WELL GET SOME THINGS TO WORK
SO I CAN GO AHEAD AND MAKE A FIX NOW THAT I'VE FIGURED IT OUT
SO I DECIDED TO START ANEW AND OF COURSE FOR MY SANITY I RESTARTED THE WHOLE THING IN RUST AND YES WE ARE FINALLY GETTING TO THE PART WHEN I TALK ABOUT RUST
SO I DO HAVE A FEW QUESTIONS
SO I DON'T CONSIDER THIS A GOOD APPROACH FOR UIS
SO I DON'T MYSELF SEE A SEMANTIC DIFFERENT HERE BETWEEN THIS PANIC VERSION AND THE ORIGINAL BROKEN VERSION
SO I ENDED UP WITH FINDING A LOT OF DIFFERENT OR OUTDATED DOCUMENTATION THAT IT WAS QUITE A BIT OF TRIAL AND ERROR
SO I FILE A RUST ISSUE
SO I FILE AN ISSUE
SO I FOUND MIRI
SO I GUESS I DO THIS KIND OF THING A LOT
SO I HAD TO LEARN A BUILD SYSTEM
SO I HAD TO LEARN OR REFRESH A LOT OF C PLUS PLUS WHICH IS TRICKY AND I HAD TO LEARN QT WHICH IS EXTREMELY LARGE AS A FRAMEWORK GOES
SO I HAVE
SO I HAVE SOME CODE AND IT'S NOT WORKING AND I THINK IT SHOULD
SO I HAVE THIS KIND OF SPECTRUM HERE FROM RENDERERS THAT USE MORE CPU TO RENDERERS THAT USE MORE GPU
SO I HAVE THIS LITTLE PHOTO COLLAGE THAT I MADE UP
SO I HAVE THIS TABLE HERE SHOWING WHICH APIS ARE AVAILABLE ON WHICH OPERATING SYSTEMS
SO I JUST WANTED TO BE SURE
SO I KNEW I WOULD BE LEARNING MY CONCEPTS AS WELL
SO I KNOW THAT THE FIRST FEW MONTHS OF MY WRITING C PLUS PLUS IT CERTAINLY WASN'T VERY GOOD AND I WAS MAKING ALL SORTS OF OUT OF THE BOUNDS ERRORS AND OTHER ISSUES THAT JUST WOULDN'T HAPPEN IN RUST
SO I LEARN MOSTLY BY READING AND SOME BUT DOING
SO I NEVER REALLY LOOKED INTO THEM
SO I POSTED A LINK TO THE REPOSITORY AND OUR PAPER EXPLAINING OUR SYSTEM IN THE CONFERENCE ROOM CHAT SO IF PEOPLE WANT TO TAKE A LOOK AT OUR LIBRARY AND HAVE A PLAY ABOUT IT SEE HOW THE GENERATED RUST CODE LOOKS
SO I SAID PREVIOUSLY THAT THE PERIPHERALS ARE THE INTERFACE TO THE OUTSIDE WORLD
SO I SAY I'M GONNA GO AHEAD AND DIG INTO THIS
SO I TAKE MY EXISTING BLINKY EXAMPLE WHICH I'VE RUN AND I KNOW THAT IT WORKS
SO I THINK
SO I THINK I WANTED TO JUMP ON TO MORE TECHNICAL QUESTIONS BUT I THINK WE ACTUALLY HAVE TO GO TO THE NEXT TALK BUT YOU SHOWED US THE NEXT PROJECT WHICH IS SUPER COOL
SO I THINK IN SOME REGARDS C PLUS PLUS REALLY CARES ABOUT ITS EXPERT DEVELOPERS
SO I THINK IT'S SORT OF A VERY IMPORTANT USE CASE OR POSSIBILITY FOR RUST IS SORT OF AN ALTERNATIVE BACKEND IMPLEMENTATION LANGUAGE
SO I THINK LET'S TAKE A LOOK AT THE LLVM IR THAT'S GENERATED FOR THIS CODE
SO I THINK REALLY THESE ARE
SO I THINK THAT IS WHAT ULTIMATELY HURTS THE TEACHABILITY OF RUST FROM THE START
SO I THINK THAT IT'S GOOD TO STILL WAIT UNTIL LATER TO WORRY ABOUT STACK VERSUS HEAP
SO I THINK THAT THAT'S THE PART THAT HURTS THE TEACHABILITY MOST
SO I THINK THE MOST DEVELOPED ONE I HAVE DONE IN THE PAST IS SOMETHING WITH PY GAME AND I WAS SORT OF USING THE OBJECT ORIENTED TOOLS THERE TO MAKE
SO I WAS PREVIOUSLY IN MY TALK I WAS TALKING ABOUT YOU DON'T HAVE ACCESS TO THE STANDARD LIBRARY BUT YOU HAVE ACCESS TO THE CORE LIBRARY
SO I WAS WORKING ON SOMETHING THAT IS MORE OR LESS THE HELLO WORLD OF EMBEDDED
SO I WOULDN'T MAKE THE CLAIM THAT VECTOR GRAPHICS IS BY FAR THE DOMINANT TYPE OF REPRESENTATION FOR GRAPHICAL CONTENT IN USER INTERFACES TODAY
SO I'LL HAVE
SO I'M A MECHANICAL ENGINEERING MASTER'S STUDENT AT THE UNIVERSITY OF OTTAWA
SO I'M AT A STRANGE ANGLE AT THE MOMENT
SO I'M CURRENTLY NOT SEEING ANY MORE QUESTIONS
SO I'M GONNA SAY I FOUND A BUG
SO I'M NOT ENTIRELY CONFIDENT THAT I'M USING MY UNSAFE CODE CORRECTLY HERE
SO I'M VAGUELY AWARE THAT THERE ARE THESE PROFESSIONAL IN CIRCUIT DEBUGGER SYSTEMS
SO I'VE KIND OF SHELVED IT FOR NOW
SO IF AFTER IMITATING A BRUSHSTROKE OUR PIXEL DIFFERENCE IS SMALLER THAT MEANS WE ARE MOVING TOWARDS A SPACE WITH MORE SIMILAR IMAGES AND WE SHOULD KEEP THE MUTATION AND THEN WE JUST DO IT AGAIN AGAIN AND AGAIN
SO IF ANYONE'S INTERESTED IN COMMENTING ON THE RFC AND TRYING TO HELP ME BRING IT BACK TO LIFE YOU KNOW THAT IS DEFINITELY WELCOME
SO IF LEARNING IT IS YOUR DIRECTIVE
SO IF WE NEED
SO IF WE THINK OF EAGERNESS AS A PROGRAMMING CONTEXT THAT'S THE OPTION OF LAZINESS
SO IF WE TO THAT AND SET THE MIRI FLAGS TO MIRI DISABLE ISOLATION WE CAN ACTUALLY RUN
SO IF YOU FIND YOURSELF WRITING BORING SHORT FUNCTIONS YOU'RE QUITE LIKELY ON THE RIGHT TRACK
SO IF YOU HAVE A FUNCTION THAT IS CALLED UNSAFE AND IN GENERAL THE NAME OF THE FUNCTION YOU NEED UNSAFE TO CALL IT
SO IF YOU SEARCH FOR THE AVR ASSEMBLER REFERENCE GUIDE THE
SO IF YOU STRUGGLE WITH A LANGUAGE THE FIRST TIP THE FIRST IDEA IS BE AWARE THAT IN LEARNING RUST AS IN EACH TECHNOLOGY YOU HAVE TO LOOK AT DIFFERENT THINGS
SO IF YOU'RE INSIDE A VECTOR AND YOU SAW A POINTER FROM INSIDE THE VECTOR TO ACCESS SOMETHING OUTSIDE THE VECTOR THAT IS A DANGLING POINTER
SO IF YOU'RE INTERESTED IN AN OPEN SOURCE SOLUTION YOU SHOULD GIVE TERMINUSDB A TRY
SO IF YOU'RE INTERESTED IN KIND OF HEARING ANY OF THOSE DISCUSSIONS SHAMELESS PLUG FOR MY PODCAST
SO IF YOU'RE RENDERING A FULL SCREEN RECTANGLE THE GPU GETS STRESSED OUT BY HOW MANY LINES YOU'RE TRYING TO SHOVEL THROUGH IT
SO IF YOU'RE TRYING TO SORT THIS VECTOR OF FLOATING POINT NUMBERS YOU'LL COME UP WITH AN ERROR
SO IMPROVING PROTOCOL STANDARDS THE INTERNET ENGINEERING TASK FORCE STANDARDISES NETWORK PROTOCOLS
SO IN CEREMONY AN ENTITY OFTEN REPRESENTED WITH A SINGLE ID CAN BE COMPOSED OF A NUMBER OF COMPONENTS
SO IN ESSENCE I JUST TRIED TO GET MYSELF TO THE SAME KNOWLEDGE LEVEL THAT I WOULD HAVE IN OTHER LANGUAGES
SO IN GENERAL IN DEVELOPING FOR A CONTEXT WE ABORT ON PANIC RATHER THAN GOING INTO THE STACK
SO IN MY IMPLEMENTATION I CAME
SO IN MY MIND IT REALLY IS A QUESTION OF CULTURE
SO IN ORDER TO GET A GOOD IDEA FOR EXAMPLE ABOUT OWNERSHIP I THINK IT HELPS NOT ONLY TO THINK ABOUT OWNERSHIP BUT WHILE IT'S NOT NECESSARY TO HAVE SOMEBODY ABOUT POINTER MANAGEMENT MEMORY MANAGEMENT WORKS FOR EXAMPLE IN C OR WHAT REFERENCE COUNTING MEANS IN OTHER LANGUAGES LIKE PYTHON
SO IN ORDER TO REDUCE THE AMOUNT OF INCONSISTENT BEHAVIOR BETWEEN DOG AND CAT WE'RE GOING TO CONSOLIDATE ALL OF THEIR BEHAVIOR INTO A TRAIT
SO IN RUST THIS IS ACTUALLY AVAILABLE TO US WITHIN THE TRAIT
SO IN RUST WE'RE GOING TO USE TRAITS TO INTRODUCE STUDENTS TO THE IDEA OF DEFINING SHARED BEHAVIOR
SO IN SAFE RUST YOU ARE ACTUALLY GUARANTEED AN ABSENCE OF THESE DATA RACES
SO IS THAT YOU DON'T READ A SENTENCE AND YOU HAVE THE FEELING THAT YOU HAVE TO LOOK UP EVERY SECOND WORD
SO IS THIS COURSE VIABLE
SO IT ALSO GAVE US THE CHANCE TO RE ENGINEER OUR DATA STRUCTURE SIMPLIFY CODE IMPROVE FITNESS FOR PURPOSE CHANGE THE LOW LEVEL PRIMITIVES AND CATER TO WRITE TRANSACTIONS IN PARTICULAR BUT ALSO ENABLED US TO DO SOME PERFORMANCE ENHANCEMENTS THAT WE WOULD LIKE TO HAVE DONE BUT WERE AFRAID TO DO BECAUSE IN C PLUS PLUS THERE IS KIND OF A FEAR FACTOR WHERE IF YOU HAD ANYTHING NEW YOU MIGHT ADD SOMETHING THAT CAUSES IT TO CRASH
SO IT COMPLAIN ABOUT MEMORY BEING FREED AND SOMETIMES THE POINTER THE ARRAY IS NOT DELETED YET SO IT HASN'T BEEN DROPPED
SO IT COMPLAINS ABOUT IT BEING OUT OF BOUNDS ACCESS EVEN THOUGH THE ARRAYS ARE STILL THERE
SO IT HAS THE TRADEOFFS THAT I MENTIONED WHERE IT'S BETTER SUITED TO A THREE D GAME WHERE YOU RENDER SOMETHING THAT'S THE SAME
SO IT IS A NICE
SO IT IS FUNNY BECAUSE THE STANDARD LIBRARY USES FOREIGN FUNCTIONS BUT MIRI USES THE STANDARD LIBRARY TO EMULATE SOME OF THOSE FOREIGN FUNCTIONS
SO IT IS NOT ALL THAT BAD
SO IT IS SUPER IMPORTANT NOW TO HAVE A WAY TO USE A CUSTOMER LOCATOR FOR MIRI TO TEST WITH DIFFERENT ALLOCATORS FOR EXAMPLE
SO IT IS THE LANGUAGE LEVEL
SO IT IS WORTHWHILE NOT TO GET DISCOURAGED IF YOU RUN INTO THIS STEEP LEARNING CURVE AT THE BEGINNING
SO IT MIGHT BE THAT IN A COUPLE OF YEARS A COMPLETELY SECURE VERSION OF SOME SOFTWARE NOW MIGHT ACTUALLY BE INSECURE WITH A NEW COMPILER VERSION WHICH I FIND VERY SCARY
SO IT OFFLOADS A LOT OF THE WORK TO THE GPU
SO IT TURNS OUT THAT THE PROBLEM HERE IS THAT LLVM SEEMS TO BE ABLE TO COMPLETELY ELIMINATE THIS MASK VARIABLE SO THIS MASK VARIABLE IS SECRET BECAUSE IT DIRECTLY DEPENDS ON THIS CONDITIONAL VALUE WHICH WE SAID WAS SECRET
SO IT WAS PRETTY BIG
SO IT'S A BIT LIKE A STALACTITE HANGING FROM THE ROOF OF A CAVERN WHERE AS WE ADD ADDITIONAL CONTEXT OUR STALACTITE GROWS DOWN
SO IT'S A GOOD FIT FOR GPUS
SO IT'S ACTUALLY MORE LIKE A 99% CHANCE THAT THE BUG'S IN MY CODE
SO IT'S BEEN PAST ATTEMPTS ABOUT OKAY WE CAN HAVE CUSTOM TOOLING TO DO THIS AND THIS ALL SINGING AND DANCING BUT WE TRIED TO MAKE SOMETHING RELATIVELY SIMPLE AND UNINTRUSIVE THAT COULD WORK FOR MULTIPLE WORKFLOWS
SO IT'S FIXED
SO IT'S GOING TO BE 0 017 WHICH IS THE SAME AS ONE DIVIDED BY 58
SO IT'S OFTEN AT LEAST FOR SOMEBODY LIKE ME A BETTER APPROACH TO DO VERY VERY SMALL THINGS AND PRACTICE THEM THAN DO SOMETHING ELSE AGAIN
SO IT'S PRETTY COMMON TO STILL HEAR STUFF LIKE OH YEAH MIRI IS THE CONSTANT EVALUATION FOR RUST
SO IT'S THE SAME SORT OF EXAMPLES
SO JUST ONE SECOND SEE IF ANYONE CAME IN
SO JUST TO BRIEFLY GO OVER THESE GROUND RULES AGAIN I'M GOING TO TRY TO SHOW EVERYBODY RESPECT TODAY
SO JUST TO GET A VAGUE IDEA WHAT HAVE EACH OF THESE ARE WE'LL USE THE METAPHOR OF AN OLD SCHOOL PAPER PUSHING OFFICE
SO LEAD CODE OR PRESENTER CODE OR JUST PORTING YOUR COMMANDLINE A SIMPLE COMMANDLINE TOOL IS SOMETHING THAT IS WELL LIMITED IN SCOPE AND THAT GIVES YOU A FEELING OF SUCCESS WHEN YOU RUN
SO LET ME ME INTRODUCE MYSELF
SO LET'S BEGIN BY TALKING ABOUT UNSAFE RUST AND UNDEFINED BEHAVIOUR
SO LET'S CONNECT OUR ARROWS FROM EARLIER
SO LET'S GET BACK TO MY PROJECT
SO LET'S JUST START
SO LET'S LOOK AT A COUPLE EXAMPLES
SO LET'S LOOK AT THE SAME THING FOR AN INTERRUPT
SO LET'S LOOK INSIDE THE BOX AND WE FIND THAT THERE ARE FOUR ADDITIONAL BOXES
SO LET'S READ THIS FROM THE OUTSIDE IN
SO LET'S SEE HOW IT IT LOOKS IN ACTION
SO LET'S TAKE A LOOK AT SOME ASSEMBLER
SO LET'S TAKE A LOOK AT WHAT THE PROCESSES ARE THAT ARE USED TO MODIFY THE RAW METAL INTO THE THESE GOODS THAT WE KNOW AND LOVE
SO LET'S WALK THROUGH PARSING A TCP HEADER
SO LIKE
SO LIKE THE PAPER I TALKED ABOUT IS HERE AS WELL AS EVAN'S
SO LIKE YOU SAID EARLIER WE CAN MAKE THIS WORK BY MAPPING OUR ERROR TO UNIT
SO LLVM NEEDS TO MAKE SURE TO GUARANTEE THAT WHAT WE WROTE DOWN IN THE CODE IS SAFE IN THE EMITTED BINARY THAT MEANS NO BRANCHING ON SECRETS NO BRANCHING WITH SECRET INDICES AND NO VARIABLE TIME INSTRUCTIONS
SO LONG TERM ONE COULD HAVE A VM LIKE A FULL FUNCTIONING VM IN MIRI
SO LOOKING AT OUR COMPILER MODEL AGAIN
SO MANY EXPLANATIONS ANYMORE
SO MAYBE YOU DON'T NEED SO MUCH
SO MOST LIKELY YOU WILL HAVE TO INTERACT WITH A C OR C PLUS PLUS LIBRARY OR CREATE THAT INTERACTS WITH A C PLUS PLUS LIBRARY
SO MOVING ON TO THE
SO MY PROGRAMS ON EMBEDDED ALMOST NEVER DO I THINK ABOUT REACHING FOR THE HEAP
SO NOW BECAUSE THESE EMBEDDED DEVICES ARE SO LIMITED IT'S ACTUALLY QUITE EASY TO RUN A PROGRAM ON YOUR DESKTOP COMPUTER THAT SIMULATES THE ENTIRETY OF THE EMBEDDED DEVICE
SO NOW IMAGINE WE DREW THIS BRUSHSTROKE ON A CANVAS AND JUST LIKE WE THOUGHT OF SCALE OF PARAMETERS WE CAN THINK OF THE BRUSH AS A PARAMETER OF THE CANVAS
SO NOW IT'S TIME FOR THE WALK THROUGH AND TALKING A BIT ABOUT NO STD
SO NOW OUR STACK HAS REGISTER ZERO'S PRIOR VALUE REGISTER 1'S PRIOR VALUE AND THE STATUS REGISTER'S PRIOR VALUE
SO NOW THAT GETS TO THIS BIT IN THE MIDDLE
SO NOW WE CAN DISCUSS WHAT UNSAFE CAN DO
SO OF COURSE IN TERMS OF CHALLENGES I'M SURE EVERYONE IN THE RUST COMMUNITY KNOWS ABOUT CHALLENGES OF FFI BUT I DON'T WANT TO BELABOUR THE POINT
SO ON 14 WE SAVED THE STATUS REGISTER INTO REGISTER ZERO
SO ON ONE END WE HAVE DUNE RENDERING ENTIRELY AND THEN THERE'S TESSELLATION THAT BUSTS APART THIS INTO TRIANGLES AND SHOVELS THEM OVER TO THE GPU TO BE RENDERED
SO ON THE BROKEN CODE WE HAVE THE SAME SEQUENCE AT THE START FOR THE PROLOGUE
SO ON THE LEFT WE SEE WE HAVE A REGISTERED
SO ONCE AGAIN THANK YOU SO MUCH ANDREW FOR THAT EPIC TALK
SO ONE DIVIDED BY 16 MILLION IS REALLY FAST 16 NANOSECONDS
SO ONE IS TRUE ZERO IS FALSE BUT IF YOU TAKE A THREE AND YOU TRY PUT THAT AN INTO A BOOLEAN DOING THAT IS UNDEFINED BEHAVIOUR BECAUSE THREE IS NOT SPECIFIED AS A BOOLEAN
SO ONE OF OUR QUESTIONS IS WOULD RUST BE A BETTER PUT FOR SUCH A COURSE
SO ONE OF THE EXAMPLES THAT WE ARE WORKING ON AT THE MOMENT IS QUIC
SO ONE THING I ACTUALLY FOUND INTERESTING WAS A RESEARCH PAPER DONE IN 2011 BY SOME RESEARCHERS WHO LOOKED AT RACKET
SO OUR PROLOGUE IS FINE
SO OUR SOLUTION HAS BEEN A LATE OPTIMISATION APPROACH AND THE WAY THAT WE DO THIS IS WE DEVELOPED THE LOW LEVEL PRIMITIVES IN RUST FOR OUR LOW LEVEL STORAGE LAYER AND THEN WE DESIGNED THE ORCHESTRATION OF THESE IN PROLOG
SO PERHAPS IN FIVE YEARS THE COMPILER IS ACTUALLY ABLE TO LOOK INTO THIS ASSEMBLY DIRECTIVE AND SEE THAT NOTHING HAPPENS
SO PORTABILITY IS KIND OF A HARD QUESTION
SO PUSH AND POP TAKE REGISTER VALUES TO AND FROM THE STACK
SO RIGHT NOW IN THE CURRICULUM FOR THE COMPUTER SCIENCE STUDENTS THAT'S JUST SIMPLY HOW IT IS
SO RUST ALSO HAS THESE OPT IN LOW LEVEL CONTROL FEATURES WHERE WE CAN YOU KNOW WE CAN DO THE
SO RUST KEEPS A FORK OF LLVM
SO RUST MAKES THE DESIGN DECISION TO HAVE MANY THINGS THAT ARE USEFUL BUT ARE NOT IN THE STANDARD LIBRARY
SO RUST READS THE TEXT OF YOUR SOURCE CODE LET'S SAY AND PARSES IT TO PRODUCE AN ABSTRACT SYNTAX THREE OR AST
SO RUST'S SORT OF FIRST CLASS DEPENDENCY MANAGEMENT IS REALLY IMPORTANT TO ME AND IT SORT OF
SO SCIENTIFIC SOFTWARE IS SORT OF AN INTERESTING CASE WHERE YOU HAVE THESE VERY STRICT REQUIREMENTS
SO SHE CAN RUN UNTIL MUCH LATER
SO SIMPLE APPLICATION DOMAIN
SO SO MAYBE YOU COULD ANSWER THEM IN CHAT OR LATER ON
SO SOMETIMES COMPILATION OF A PROGRAM OR INTERPRETATION IS THE FIRST AND LAST UNIT TEST THAT IT GETS
SO SORT OF JUMPING RIGHT IN JUST TO SOME OF THE RUST FEATURES I FIND VERY USEFUL FOR WRITING NUMERICAL CODE
SO SORT OF TAKEN TOGETHER RUST'S SAFETY GUARANTEES AND THE FUNDAMENTALS OF THE LANGUAGE HAVE A LARGE QUALITATIVE IMPACT ON WHAT KIND OF CODE WE'RE CAPABLE OF WRITING
SO SORT OF THE FINAL THING WITH SCIENTIFIC SOFTWARE IS THAT THE DEVELOPERS USUALLY HAVE OTHER JOBS
SO STEPHEN AND PAUL PERKINS TWO PEOPLE INVOLVED IN THIS PROJECT ARE HEAVILY INVOLVED WITH THE IETF SO I THINK THEY'RE HAVING DISCUSSIONS TO SEE HOW WE CAN GET THIS DEPLOYED
SO STUDENTS NOT HAVING TO LEARN ABOUT THESE GIVES THEM A LOT OF TIME TO FOCUS ON THE OTHER PARTS OF RUST THAT ARE EVEN MORE IMPORTANT IN THESE EARLY DAYS
SO SUBTRACTING 1 IS WHAT'S ALLOCATING SPACE ON THE STACK
SO SUPPOSE YOU WANT YOUR APP TO RUN ON BOTH A RETINA MACBOOK AND AN OLDER TEN EIGHTY P MONITOR IF YOU'RE USING IMAGES YOU HAVE TO EXPORT A NEW IMAGE FOR THE RETINA MACBOOK WHEREAS THEY CAN BE RENDERED THE SAME ON SIMILAR PIXEL DENSITIES
SO TAKE IT SLOW
SO THANK YOU SO MUCH FOR YOUR PATIENCE ACTUALLY
SO THANK YOU VERY MUCH FOR YOUR TIME TODAY
SO THANKS AGAIN FOR THE GREAT PRESENTATION ABOUT TENSORBASE
SO THAT ALSO DRIVES A LOT OF OUR REQUIREMENTS
SO THAT BEING ALL SAID THE NORM HERE WITH ERROR MESSAGES
SO THAT IS HOW WE CAN USE MIRI USE IT TO DETECT UNDEFINED BEHAVIOUR
SO THAT IS THE FIRST DIFFERENCE
SO THAT IS WHAT WE MEAN WHEN WE SAY COMPILERS ARE PROBLEMATIC
SO THAT LETS YOU WHETHER YOU'RE ON DIRECT X OR OPENGL OR METAL WHETHER YOU HAVE AN EXISTING GAME ENERGY YOU WANT TO USE OR YOU'RE USING SOME PROPRIETARY CONSOLE API THAT I COULDN'T HAVE FORESEEN OR ADDED TO OCHRE AS AN API YOU CAN JUST ADD THE SUPPORT YOURSELF VERY STRAIGHT FORWARDLY USING SOME SIMPLE OPERATIONS
SO THAT TERM IS NOT NEW
SO THAT THEY CAN BETTER UNDERSTAND HOW TO USE THE OPTION TYPE LATER ON WHEN WE DECIDE TO INTRODUCE NON EXISTENT DATA
SO THAT'S A BIT MYSTERIOUS
SO THAT'S ALL THAT I HAVE TO SAY NOW
SO THAT'S EVEN MORE PIXELS YOU HAVE TO PAINT PER SECOND
SO THAT'S HOW OCHRE WORKS
SO THAT'S THE DEBUGGING AND OBSERVABILITY
SO THAT'S THE HARD PART
SO THAT'S VERY CURIOUS
SO THE ANSWER WITH SOMEBODY HAVEN'T PUBLISHED USING IT YET BUT WATCHING THIS SPACE
SO THE AVR
SO THE BACKGROUND WAS BASICALLY I HAD MY DESKTOP APPLICATION I STARTED OUT WITH QT
SO THE BORROW CHECKER THERE IS A COST BUT HUGE BENEFITS THAT COME FROM IT NOT JUST SAFETY BUT ALSO POTENTIALLY SPEED
SO THE CODE THAT I'VE WRITTEN USES AN INTERRUPT SERVICE ROUTINE
SO THE CONSUMER OF THE LIBRARY LIKE IT COULD BE A BINARY FORCE WOULD FORCE THE LOG IMPLEMENTATION USED BY ITSELF AND OTHER DEPENDENCIES OF THAT GRID
SO THE FIRST LINE HERE WHAT THIS DOES IS IF THIS MASK IS ONLY ONCE SO IF THE CONDITIONAL WAS TRUE THEN IT WILL X OR THE VALUE IN A THIS WILL SET THE VALUE IN A TO ZERO
SO THE FIRST MODEL IS A BIT
SO THE FIRST PARSER WILL BE FOR SOURCE PORT
SO THE FIRST THING THEY WORKED ON I WAS WORKING ON THIS FOR ABOUT A YEAR STARTING ABOUT A YEAR AND A HALF AGO
SO THE FORM WITH A LOT OF ERROR MESSAGES AND A LOT OF DIFFERENT PROGRAMMING LANGUAGE ECOSYSTEMS IS JUST LIKE THEY'RE
SO THE FRAME POINTER ALWAYS POINTS AT THE CURRENT FUNCTION STACK FRAME
SO THE GOOD NEWS IS THAT ANY OF THOSE ARE ON UNDEFINED BEHAVIOUR
SO THE MAIN CLASS OF REGISTERS ARE THESE GENERAL PURPOSE REGISTERS
SO THE MAIN GIST OF THIS TALK WILL BE THAT SOME OF YOU MAY KNOW THAT CRYPTOGRAPHIC ENGINEERS TEND TO WRITE A LOT OF THEIR CODE IN ASSEMBLY
SO THE MAIN PROBLEM HERE IS THAT COMPILERS ARE IN SOME SENSE PROBLEMATIC
SO THE MOST IMPORTANT DIFFERENCE IS THAT IN AN EMBEDDED CONTEXT YOU HAVE EXTREMELY LIMITED RESOURCES
SO THE OTHER IMPORTANT TREND IS THAT GPUS HAVE BECOME REALLY UBIQUITOUS IN CONSUMER HARDWARE
SO THE PROBLEM IS HOW DO WE DEAL WITH DEPENDENCIES AND ESPECIALLY THOSE DEPENDENCIES WHICH WON'T COMPILE
SO THE PROBLEM WITH THE IETF IS THERE ARE SO MANY DIFFERENT GROUPS IT'S IMPOSSIBLE TO GET A GROUP CONSENSUS FOR THE WHOLE ORGANISATION SO WHAT WE'VE GOT AT THE MOMENT IS A SMALL SIDE MEETING AT THE FORMAL DESCRIPTIONS TECHNIQUE AND SIDE GROUPS I THINK WHICH IS AIMING TO SAY OKAY HOW CAN WE DEPLOY THIS
SO THE PUSH STATEMENT LIKE I ALLUDED TO A MOMENT AGO WE'RE PUSHING A REGISTER VALUE ON TO THE STACK
SO THE QUESTION BECOMES HOW DO WE STOP AND SEARCH FOR SOMETHING INTERESTING
SO THE QUESTION THAT I KIND OF WANTED TO POSE DURING THIS TALK IS THIS DELTA BETWEEN THE BEST IN CLASS ERROR MESSAGES AND KIND OF EVERYONE ELSE I SUPPOSE IS
SO THE SERVO MOTOR IS A SIMPLE ROTATING MOTOR BUT WE DO NOT NEED IT TO GO ALL THE WAY TO THE END OF THE ROTATION SO WE CAN THINK ABOUT IT AS A LIGHT DIMMER WE USE SOMETHING CALLED PULSE MODULATION
SO THE SORT OF DEFAULT WAY OF SORTING FLOATING POINT NUMBERS DOESN'T ACTUALLY WORK
SO THE SUMMARY IS QUITE EASY
SO THE UNWRAP NEVER ACTUALLY GETS CALLED
SO THE WAY ERROR MESSAGES ARE KIND OF SURFACED IN RUSTC
SO THE WHOLE POINT OF US DEVELOPING THE NETWORK PACKET REPRESENTATION SYSTEM WAS TO HAVE SOMETHING THAT WAS COMPLETELY AGNOSTIC OF ANY PROGRAMMING LANGUAGES OR OUTPUT LIBRARIES WE WANT TO USE IN THE ACTUAL PARSER FIELDS THEMSELVES SO IT SHOULD BE FAIRLY EASY FOR US TO ADOPT TO THESE THINGS I THINK
SO THEN THERE WAS A SECONDARY PROBLEM WHICH IS THAT HDT WAS NOT DESIGNED FOR WRITE TRANSACTIONS
SO THEN WHY DO WE FOCUS ON RUST
SO THERE ARE GOOD NEWS FOR US RUST DEVELOPERS PEOPLE IN THE RUST COMMUNITY
SO THERE ARE SOME FEATURES THAT WE KNOW WE'RE GOING TO ADD DIRECTLY TO THE RUST LIBRARY SO WE HAVE SPECIFIC FEATURE ENHANCEMENTS THAT WE ARE NEVER GOING TO EVEN BOTHER TRYING TO DO IN PROLOG
SO THERE ARE TOOLS THAT YOU CAN USE VERIFICATION TOOLS THAT CAN DETERMINE IF ON DIFFERENT INPUTS THERE ARE DIFFERENT RUNTIMES SO THAT IS ONE OF THE WAYS THAT YOU CAN DETERMINE IS IF A PROGRAM HAS NON SECRET INDEPENDENT RUNTIMES
SO THERE CAN BE MANY THINGS THAT YOU WOULD LIKE TO LEARN THAT WOULD POTENTIALLY BE USEFUL FOR YOUR PROJECT
SO THERE IS A SECOND QUESTION
SO THERE IS SOME WAY HOW RUST CAN BE IN A WAYSIDE CHANNEL RESISTANT
SO THERE IS THAT
SO THERE MIGHT BE ROOM FOR A CUSTOM TOOL TO BE USED WHICH WOULD RUN ALL OF THE COMPILATION AND TESTING FOR STUDENTS WITHOUT THEM HAVING TO LEARN ANYTHING EXTRA
SO THERE REALLY IS ONLY ONE VIABLE RUST COMPILER RIGHT NOW EVEN THOUGH THERE'S WORK ONGOING TO ADD IT TO GCC
SO THERE WERE A NUMBER OF SORT OF COMPLEX FACTORS THAT WENT INTO THE PROBLEMS THAT THE THERAC 25 HAD
SO THERE'S A SEPARATE PHASE AFTER PARSING WHEN RUSTC IS RUNNING THROUGH YOUR CODE THAT SPECIFICALLY CHECKS FOR MUTABILITY
SO THERE'S A WONDERFUL ONE FOR AVR THAT'S AN OPEN SOURCE PROJECT CALLED SIM AVR
SO THERE'S ALSO THIS NOTION OF VERY SAFE DEFAULTS TO A LOT OF OPERATIONS
SO THERE'S EVIDENCE THAT IT IS A GOOD IDEA TO USE GPU ACCELERATION TO RENDER THE UI FOR BOTH EFFICIENCY AND POWER EFFICIENCY REASONS
SO THERE'S LIKE THIS NICE ERROR INDEX DOCUMENTATION KIND OF CLASSIFYING THE ERROR BY THIS INDEX
SO THERE'S MANY TRADEOFFS BETWEEN THESE LANGUAGES
SO THESE ARE LARGER ORCHESTRATED THEY'RE NOT AS LOW LEVEL SO THEY HAVE LOGIC IN THEM
SO THESE FUNCTIONS CAN BE CALLED FROM THE BROWSER AND WE ARE VERY FLEXIBLE IN CHOOSING IN WHAT ORDER WE CALL THEM AND WHAT KIND OF STATE WE RECORD
SO THESE MIGHT BE PEOPLE WHO ARE PRIMARILY PHYSICISTS OR CHEMISTS AND BIOLOGISTS
SO THEY ARE ENSURING EVERYONE OF THEIR PROGRAMS IS RUNNING CORRECTLY
SO THIS COULD ACTUALLY BE ANOTHER ADVANTAGE
SO THIS FEEDS INTO MY OTHER QUESTION SO I GUESS YOU CAN USE THE HIGHER LEVEL PARSERS FOR TCP UDP WHAT NOT REGARDLESS OF THE UNDERLYING TYPES OF IPV4 VERSUS VERSION 6
SO THIS FIRST SECTION WHERE WE PUSH SOME THINGS ON TO THE STACK AND DO SOME IN AND OUT
SO THIS IS A FOREIGN FUNCTION WRITTEN IN C
SO THIS IS A GREAT FIRST STEP FOR TEACHING STUDENTS HOW TO READ RUST PROGRAMS
SO THIS IS A RESULT FROM 2017
SO THIS IS ANOTHER THING THAT WE HAVE TO TEACH STUDENTS HOW TO USE AND HOW TO USE PROPERLY
SO THIS IS BASICALLY I BUILT A CONVEYOR BELT AND ANY ERRORS COMING DOWN I JUST THROW INTO THE TRASH �BE IT'S IMPORTANT TO NOTE THAT THIS ERROR NEVER ACTUALLY GETS CALLED
SO THIS IS FOR THE SERVO MOTOR
SO THIS IS JUST INTENDED TO KIND OF GIVE A BROAD OVERVIEW
SO THIS IS LIKE A SUPER HIGH LEVEL OVERVIEW OF THE RUST COMPILATION PIPELINE
SO THIS IS THE ROOT OF THE DEPTH FIRST SEARCH SEARCH TREE AND WILL GENERATE THE PARSER COMBINATOR FOR THIS LAST AFTER WE GENERATED ALL THE REQUIRED DEPENDENT PARSERS AND PARSER COMBINATORS
SO THIS IS THIS STORY WILL BE TRUE FOR BASICALLY ANY PROGRAMMING LANGUAGE THAT IS COMPILED
SO THIS IS WHAT WE'RE SUPPOSED TO DO HERE
SO THIS LETS YOU BE BOTH MORE EFFICIENT AND HIT YOUR FRAME DEADLINES AND ALSO MORE POWER EFFICIENT SO THAT YOU DON'T DRAIN THE BATTERY OR USE TOO MUCH POWER JUST FOR RENDERING SOMETHING SIMPLE LIKE A UI WHICH BECAUSE PRESUMABLY YOU WOULD LIKE TO USE THE REST OF YOUR CPU FOR OTHER APPLICATIONS
SO THIS MACRO IS AN ATTRIBUTE MACRO SINCE WE ARE WORKING NO STD WE HAVE TO ASSUME THAT IS THE POINT OF ENTRY OF THE CODE AND THE EXCLAMATION MARK HERE IS NEVER TYPE WHICH MEANS NOTHING SHOULD RETURN FROM THIS FUNCTION
SO THIS MEANS THAT YOU CAN EMULATE FOREIGN FUNCTIONS EVEN IF YOU ARE NOT IN THE PLATFORM THE PROGRAM IS GOING TO BE COMPILED ON
SO THIS PART SIMPLY DOES NOT EXIST
SO THIS TRIGGERS SOMETHING IN MY MIND
SO THOSE ARE REAL POINTERS
SO THREAD SAFETY WAS ONE OF OUR MAJOR HEADACHES
SO TIER 3 MEANS THAT IT'S SUPPORTED BY THE RUST COMPILER BUT IT'S NOT SUPPORTED
SO TO GET INTO A LITTLE BIT MORE DETAIL ABOUT WHAT A VECTOR RENDERER HAS TO DO THERE ARE TWO ASPECTS
SO TO RECAP THE SYSTEM THAT WE DEVELOPED IN THIS PROJECT
SO TO START OFF IF WE CAN KIND OF DISTILL DOWN ERROR MESSAGES INTO KIND OF THIS NICE STANDARD FORMAT WHERE UP AT THE TOP HERE YOU CAN SEE IS WHAT'S CALLED THE LEVEL WHERE IT TELLS YOU IS THIS AN ERROR
SO TO STEP BACK A LITTLE BIT AND TRY TO MAKE SENSE OF ALL OF THESE DIFFERENT ERRORS
SO TO THE LOVELY PEOPLE IN THE STREAM THIS IS ABOUT THE LAST CHANCE YOU GET TO ASK MORE QUESTIONS
SO TOOLS LIKE CARGOES EXPAND THE GENERATED CODE AND MAYBE CHECK OUT THE STATE MACHINE THAT HAS BEEN GENERATED TO SEE
SO USE IT BY ALL MEANS
SO WE ALREADY HAVE SOMETHING LIKE THAT ON THE RUST PLAYGROUND SO IT'S NOT THAT BIG OF A DEAL AND WELL SO I TRIED IMPLEMENTING THIS IDEA IN PRODUCTION FOR A SYSTEMS PROGRAMMING COURSE AND SURPRISINGLY THIS INFRASTRUCTURE IS NOT REALLY HARD TO PROVIDE AND IT'S NOT EXPENSIVE BECAUSE A SINGLE CPU OPTIMISED VIRTUAL MACHINE CAN EASILY HANDLE HUNDREDS OF THOUSANDS OF COMPILATION REQUESTS PER DAY BUT STILL WE NEED TO MAKE SURE THAT THIS INFRASTRUCTURE IS EASILY AVAILABLE AND IT SHOULD BE POSSIBLE TO DEPLOY IT TO DEPLOY THIS COMPILATION SERVER LOCALLY AND PRIVATELY
SO WE ALSO ENDED UP TRAMPOLINING THROUGH A LIGHT C SHIM WHICH IS NOT THE BEST APPROACH
SO WE ALWAYS START A SOURCE CODE WITH OUR RS FILE AND END UP IN MACHINE CODE OR IN A BINARY OR DYNAMIC LIBRARY SOMETHING LIKE THAT
SO WE ARE GOING TO BECAUSE WE ARE IN NO STD WE ARE GOING TO NEED TO IMPORT A PANIC HANDLER AND PANIC HALT HERE AND THOSE TWO ARE THE CRATES I'M IMPORTING TO MAKE IT WORK
SO WE ARE USING TIMER 1 WHICH IS SIXTEEN BIT AND WE ARE PRESCALING IT WITH A FACTOR OF 64 HERE
SO WE CAN ADD THIS ONE LINE TO OUR CODE AND IT SAYS ESSENTIALLY GIVE ME A DEBUG REPRESENTATION OF MY STRUCTURE
SO WE CAN GO AHEAD AND LOOK AT AN EXAMPLE LIKE THIS
SO WE CAN PUSH REGISTER ZERO 1 STATUS REGISTER AND 24
SO WE CHERRY PICK THE FIX INTO THAT FORK AND THEN NEED TO UPDATE THE RUST COMPILER
SO WE GO INTO THE INTERRUPT SERVICE ROUTINE
SO WE HAD FEELINGS ABOUT WHAT THE INTERFACE SHOULD BE FOR A LIBRARY HDT WASN'T IT AND IT ALSO HAD THESE CRASHING PROBLEMS AND WE WERE FINDING IT HARD TO FIND THE SOURCE OF THEM
SO WE HAD SO I THINK I HAD A SMALL FILE FOR TEST WHEN THAT I WAS DOING THE INTERNSHIP ABOUT WHAT IF THIS HAPPENS AND NON BITE ALIGNED WORDS WAS ONE OF THEM
SO WE HAVE
SO WE HAVE 5 GENERAL PURPOSE PINS TO USE
SO WE HAVE A FUNCTION CALL
SO WE HAVE A PUSH AND AN IN FOLLOWED BY A POP AND AN OUT
SO WE HAVE NOW CONFIRMED WE HAVE A BUG IN LLVM
SO WE HAVE OUR TINY COMPUTER WIRED UP TO OUR TINY LIGHT AND WE WRITE A PROGRAM FOR THE MICROCONTROLLER
SO WE HAVE PANIC AND IT SAYS THE LENGTH OF THIS VECTOR IS 3 WE ARE TRYING TO GET THE TENTH ELEMENT
SO WE HAVE THE ANIMAL SHARED STRUCTS THAT WE'VE NOW INTRODUCED THAT DOG AND CAT CAN BOTH CONTAIN INSTANCES OF
SO WE HAVE VERY LITTLE TIME LEFT BUT THERE WAS A LOT OF CHATTER IN THE CHAT ROOM SO I GUESS PEOPLE CAN FIND YOU IN THERE AND WE CAN GET A FEW MORE QUESTIONS
SO WE INITIALLY EXPECTED TO WRITE A LOT MORE OF THE PRODUCT IN RUST SO WE STARTED OFF REPLACING THE HDT LAYER
SO WE KEEP GOING
SO WE MUST OBEY RUST'S RULES FOR DEFINING THINGS THAT ARE SIMILAR
SO WE NEED TO KEEP DIGGING
SO WE NEED TO MOVE STEP 1 DOWN TO STEP 2
SO WE ORGANIZED OUR SYSTEMS TO LISTEN FOR SPECIFIC EVENT TYPES
SO WE READ IN THE FRAME POINTER AND WE
SO WE SAID PREVIOUSLY OUR STACK HAS A STACK FRAME FOR EACH FUNCTION
SO WE SEE THAT WE HAVE SPECIAL EPILOGUE CODE WITH REGISTERS 1 ZERO AND THE STATUS REGISTER
SO WE START BY DOWNLOADING EVERYTHING
SO WE STARTED WITH THIS STORAGE LAYER IN RUST AND HAVE EXTENDED THIS TO SEVERAL LIKE OPERATIONS THAT HAVE PROVED TO BE SLOW WHEN THEY WERE IN PROLOG AND NEEDED TO BE FASTER
SO WE UNCERTAINTY OUR FRAME POINTER RESTORATION CODE THERE
SO WE WERE NOT INITIALLY A RUST HOUSE
SO WE WOULD LIKE TO HAVE A VECTOR GRAPHICS RENDERER FOR OUR UIS
SO WE'LL GO BACK TO BLINKY
SO WE'LL READ IN THE FRAME POINTER INTO REGISTER 28 AND 29
SO WE'LL SEE FREQUENTLY THE TERM LLVM IR
SO WE'RE
SO WE'RE GOING AHEAD AND COLLECTING AND WE USE A TURBOFISH TO NOTE WHAT KIND OF COLLECTION WE WANT TO COLLECT INTO
SO WE'RE GOING TO BE TALKING A BIT MORE ABOUT HOW THE STACK WILL WORK
SO WE'RE GOING TO READ IN THE STATUS REGISTER
SO WE'RE GOING TO TURN ON AND OFF OUR LIGHT FOREVER
SO WE'RE GONNA REMOVE ALL OF OUR EXTERNAL REFERENCES
SO WE'RE GONNA START WITH A PUSH AND POP ON REGISTER ZERO SO IF WE'RE STARTING FROM THE TOP OF THE FUNCTION ONLINE 2 WE PUSH REGISTER ZERO ON TO OUR STACK
SO WE'VE NOW DETERMINED THAT THIS COMPILER IS A BOX
SO WELL MANY DIFFERENT THINGS
SO WHAT ARE MY NEXT STEPS
SO WHAT ARE SOME OTHER THINGS THAT I'M THINKING ABOUT
SO WHAT DID I DO
SO WHAT HAPPENS IF YOU BREAK THESE RULES
SO WHAT I CAME UP WITH IS BASICALLY VUEJS WHICH I HAD TO LEARN
SO WHAT I TRIED TO DO LEARNING RUST WAS TO LEARN AT THE DESKTOP APPLICATIONS
SO WHAT IS DIFFERENT FOR OUR CALLING CONVENTION FOR AN INTERRUPT SERVICE ROUTINE AS OPPOSED TO A REGULAR FUNCTION
SO WHAT IS IT ACTUALLY DOING
SO WHAT IS THIS LLVM THING
SO WHAT THAT MEANS IS IN GENERAL WHEN I'M DEVELOPING FOR AN EMBEDDED CONTEXT I'M USING MUCH MORE NAIVE DEBUGGING METHODOLOGY
SO WHAT WE DO FIRST IS WE GENERATE A MASK FROM ITS CONDITIONAL VALUE AND THE VALUE THAT WILL COME OUT OF THIS MASK WILL BE SOMETHING LIKE EITHER ONLY ONCE OR IF THE CONDITIONAL VALUE IS TRUE SORRY
SO WHAT WE'VE IT'S MOSTLY A PROOF OF CONCEPT AT THE MOMENT
SO WHAT YOU SEE HERE ON THE LEFT IS I HAVE WRITTEN THIS NICE LITTLE CMOV FUNCTION SO IF THIS CONDITIONAL VALUE IS TRUE WHAT IT SHOULD DO IS THAT IT SHOULD MOVE THE VALUE IN B INTO A
SO WHAT'S AVR
SO WHAT'S MIRI ACTUALLY
SO WHEN IT BUILDS THESE TILES AND SPANS WHAT IT DOES IS IT JUST BUILDS THAT DATA FOR YOU AND THEN YOU CAN TAKE THAT DATA
SO WHEN PEOPLE NEED PERFORMANCE THEY START TO REACH FOR LANGUAGES LIKE C AND C PLUS PLUS
SO WHEN YOU WANT TO EXECUTE THIS SNIPPET ALL YOU HAVE TO DO IS TO CALL THESE FUNCTIONS ONE BY ONE AND THE STATE CHANGES
SO WHEN YOU'RE USING A REGISTER THAT'S ALREADY IN USE YOU CLOBBER IT
SO WITH SOMETHING LIKE THIS WE GO AHEAD AND INITIALIZE A STRING AND THEN WE GO AHEAD AND TRY TO INSERT OR BASICALLY MUTATE THAT STRING
SO WITH THAT IN MIND WHAT ARE THESE SIMPLIFIED MODELS THAT I'M GOING TO BE TALKING ABOUT
SO WITH THE CORE LIBRARY WE DON'T HAVE ACCESS TO COLLECTIONS LIKE A VECTOR OR A HASHMAP
SO WITH THE THERAC 25 WAS A RADIATION THERAPY DEVICE MANUFACTURED BY APP ATOMIC ENERGY OF CANADA LIMITED
SO WORKING IN THE RADIATION FIELD AND SORT OF GOING TO ENGINEERING SCHOOL THERE'S THE STANDARD CASE STUDY OF THE THERAC 25
SO YEAH
SO YES WE CAN USE MIRI TO DETECT UNDEFINED BEHAVIOUR EVEN IN PROGRAMS THAT USE FOREIGN FUNCTIONS
SO YES WE LIKE TO HAVE GUARANTEES AND WE DON'T WANT TO HAVE JUST HACKS
SO YOU CAN
SO YOU CAN GET THE ADDRESS OF YOUR ARDUINO AND THEN IF YOU TYPE SCREEN THEN THE TTY AND YOU CAN SEE HOW EVERYTHING IS SHOWING ON THE SCREEN
SO YOU CAN LITERALLY JOIN TWO TYPES IN A SINGLE ONE AND USE EVERY VALUE OF TYPE AS ANY OF THE POSSIBLE VARIANCE AT THE SAME TIME SO YOU NEED UNSAFE TO ACCESS THOSE FIELDS
SO YOU CAN SORT OF GET ANALOGS OF THESE FEATURES USING DIFFERENT FLAGS FOR C AND C PLUS PLUS
SO YOU CAN STILL MESS IT UP
SO YOU CAN TEST THE BEHAVIOUR OF YOUR CODE IN ISOLATION FROM THE EXTERNAL ENVIRONMENT AND THAT EXACTLY THE SAME THING THAT WE WANT TO DO WITH OUR INTERACTIVE DOCUMENTATION TOO BECAUSE WE WANT TO GIVE THE USER THE OPTION TO RUN THEIR CODE INDEPENDENT OF THE EXTERNAL ENVIRONMENT
SO YOU CAN THINK OF THE SENSOR AS A BAT
SO YOU CAN USE RAW POINTERS HOWEVER YOU WANT BUT THE REFERENCE THEN YOU HAVE TO USE UNSAFE
SO YOU COULD PARSE THE GRAPHQL IN A READ ONLY MODE THAT REFERENCES TO UNDERLYING TEXT THAT THE GRAPHQL WAS PARSED FROM
SO YOU GO TO THE TOKIO'S WEBSITE AND YOU SEE THEY HAVE REALLY NICE TUTORIALS
SO YOU HAVE A C LIBRARY THAT YOU RUN WITH YOUR RUST PROGRAM
SO YOU HAVE TO SOMEHOW TRANSLATE THESE TYPES OF SHAPES INTO TRIANGLES IN ONE WAY OR ANOTHER FOR THE GPU TO UNDERSTAND
SO YOU HAVE TO UPLOAD LESS DATA AND COMPUTE LESS DATA IN THE FIRST PLACE BECAUSE YOU INHERENTLY SKIP ALL THE WORK OF THIS SOLID SPANS
SO YOU KIND OF BUY THIS DICHOTOMY THAT I'M PRESENTING
SO YOU KNOW SWIFT WITH XCODE AND TYPESCRIPT WITH VSCODE THERE'S SOME REALLY COOL IDE STUFF THEY CAN DO THERE
SO YOU KNOW THERE WAS KIND THE LINE OF THINKING WHY ROBOTS
SO YOU'RE BASICALLY LEFT WITH THE ONLY CHOICE OF STATICALLY COMPILING THE DEPENDENCIES
SOFTWARE IS USED THROUGHOUT ALL PHASES OF METAL FABRICATION FROM DESIGN AND SIMULATION ON THE LEFT ALL THE WAY TO FINAL DELIVERY ON THE RIGHT
SOME DATABASE APPS' PERFORMANCE
SOME DIDN'T END UP GAINING TRACTION UNFORTUNATELY
SOME EXAMPLES ARE CHARACTER ABILITIES ITEMS AND THE STRUCTURE OF THE GAME
SOME FIELDS ONLY APPEAR UNDER CERTAIN CONDITIONS AND RELY ON VALUES FROM OTHER FIELDS WITHIN THE SAME PROTOCOL DATA UNIT IN THIS CASE THE TCP HEADER TO ESTABLISH WHETHER WE'RE USING THAT OR NOT
SOME FIELDS REQUIRE INFORMATION NOT CONTAINED WITHIN THIS PACKET LIKE AN ENCRYPTION KEY OR A VALUE FROM ANOTHER DATA UNIT SOMEWHERE IN THIS DRAFT
SOME GUIDANCE AS TO WHERE THE ASYNC AWAIT IS GOING IS INTERESTING AND WE ARE WATCHING THE COMMUNITY TO SEE WHERE THINGS ARE GOING RIGHT NOW
SOME IDEAS THAT WE ALL WON'T DESPISE
SOME INTERESTING CONVERSATIONS I'VE HAD WITH PEOPLE WHO WORK ON THIS MORE I KNOW THEY'VE HAD SOME PRETTY COOL IDEAS SUCH AS IF HEY IF WE HAD BETTER INTEGRATIONS INTO SOME KIND OF IDE THEN WE WOULD BE ABLE TO DO SOME OF THE THINGS THAT SWIFT AND TYPESCRIPT ARE DOING
SOME OF THE RECURSIVE DEFINITIONS
SOME OF THE UNUSUAL FEATURES THAT DRIVE OUR DESIGN REQUIREMENTS SO WE'RE AN IN MEMORY DATABASE WHICH ENABLES FASTER QUERY
SOME OF US MIGHT BE LET'S SAY MIGHT BE THINK THAT WE DON'T NEED FOREIGN FUNCTIONS AT ALL
SOME OF YOU MIGHT BE ASKING IF YOU DO THIS YOU CALL THIS FUNCTION WITH A INDEX
SOME OF YOUR DEPENDENCIES USE UNSAFE AND YOU WANT TO BE SURE THAT THEY DON'T CAUSE ANY UNDESIRED BEHAVIOUR
SOME OTHER LANGUAGES I'LL ALSO QUICKLY MENTION LIKE SWIFT AND ALSO TYPESCRIPT
SOME PEOPLE WOULD TARGET TO GET THIS WORKING
SOME TOPICS THAT I DIDN'T GET TO COVER IN THIS PRESENTATION SUCH AS LOOPS MUTABILITY AND ALGORITHMS
SOMEONE HAS ASKED IF THERE IS A WORKING GROUP WORKING ON IT ON A SOLUTION
SOMEONE WANTS TO HELP YOU OR SOMEONE IS EAGER TO LEND YOU THEIR SUPPORT RIGHT
SOMETHING CURIOUS TO NOTE THAT 17 IS BEFORE 18 BECAUSE YOU GET AN EXTRA INSTRUCTION FREE WHEN YOU ENABLE INTERRUPTS
SOMETHING ELSE THAT'S INTERESTING ABOUT SIM AVR WE CAN USE THE TRACE FILES ADDS INPUTS
SOMETHING IN A PERIPHERAL HAS DETERMINED THAT WE NEED TO SERVICE THIS INTERRUPT
SOMETHING LIKE THIS
SOMETHING THAT I DID NOT WANT TO INTRODUCE INTO THE COURSE
SOMETHING THAT I WAS NOT ANTICIPATING TEACHING TO STUDENTS
SOMETHING THAT STUDENTS WILL HAVE TO GET USED TO
SOMETHING UNSAFE IS POTENTIALLY HAPPENING HERE
SOMETIMES DISCUSSIONS AROUND IMPLEMENTATION DETAILS CAN BE LESS RELEVANT WHEN ADDRESSING AN ISSUE
SOMETIMES I KNOW THAT MY INDEX IS CORRECT AND I DON'T WANT TO PAY THE COST OF BOUNDS CHECKING
SOMETIMES THIS PROGRAM FAILS BECAUSE WHEN MIRI INTERPRETS IT IT FREES THE MEMORY FOR THE ARRAY BEFORE YOU READ THE POINTER
SOMETIMES YOU CAN LEARN SOME LITTLE PERFORMANCE IF YOU WANT MORE PERFORMANCE
SOMETIMES YOU NEED THE WORKAROUND BUT SOMETIMES YOU MAY STILL CONSIDER THE WORKAROUND
SOMEWHAT RELATED TO THAT IS IN AN EMBEDDED CONTEXT YOUR COMPILER IS A CROSS COMPILER
SORRY
SORRY FOR THAT
SORT OF REALLY HELPS IT IS THAT INTEGRATED TESTING IN RUST'S PACKAGE MANAGER MEANS THAT I THINK TESTS ARE GOING TO BE MUCH MORE LIKELY TO BE WRITTEN
SORT OF THE QUICK OR MAYBE THE PERFORMANCE ORIENTED THING BUT WE HAVE TO TELL PEOPLE THAT WE'RE DOING IT
SOUNDS GOOD
SPEAKING ABOUT THE COMMUNITY BECAUSE INSTEAD OF THINKING ABOUT THE BAD THINGS THE GOOD THINGS THAT IS TRUE WHEN I JOINED THE RUST COMMUNITY
SPECIFICALLY ON THE SAME THING
STACK AND HEAP ALLOCATIONS AND THREADS ARE THINGS TAUGHT IN LATER COURSES SO THEY'RE NOT REALLY IN SCOPE FOR THIS COURSE
START OUT SMALL LET IT GROW
STATIC MUTABLE VARIABLES
STATIC VARIABLES IN THE PROGRAM WOULD BE THERE
STAY WITH THE BORING OLD STABLE WORLD AND MOVE ALONG
STEFAN GIVES US THREE STEPS TO LEARN RUST
STEP 1 FIRST
STUDENTS WILL USE THIS TO HAVE A GREAT UNDERSTANDING OF HOW TO PROPERLY HANDLE ERRORS
SUCH AS VELOCITY TO STORE THE X AND Y VALUES
SUGGESTIONS YOU REALLY SHOULD STEAL
SURE
SURE THERE WILL BE SOME COOL STUFF TO SEE NO
SURE WE WOULD LOVE TO
SWIFT WHICH I DIDN'T USE BEFORE AND RUST WHICH I DIDN'T USE BEFORE
TAKE A VALUE FROM A GENERAL REGISTER AND PUT IT INTO A SPECIAL REGISTER
TAKE IN PRINTING AND WE MAY NEED TO USE CMYK SO ANOTHER EXPRESSION OF COLOR WITH A DIFFERENT SET OF TUPLES
TAKE THIS RUBE GOLDBERG SELF OPERATING NAPKIN AND WE'RE GOING TO PUT THIS SYSTEM INSIDE OF A BOX
TAKES THE SOURCE CODE AND NEEDS TO GO AHEAD AND PARSE THAT INTO SOME INTERNAL REPRESENTATION
TARUN HELPFULLY TEACHES RUST
TAUGHT IN RUST MIGHT LOOK LIKE
TCP OPTIONS IS AN ENUM TYPE WITH A LIMITED RANGE OF POSSIBLE CHOICES
TEACH THEM THE VERY BASICS
TELLS THE MACHINE TO NOT INTERRUPT US SO THAT WE CAN RUN SOME CODE WITHOUT BEING INTERRUPTED
TENSORBASE BENEFIT FROM PARTS OF RUST'S ECOSYSTEM
THANK YOU
THANK YOU AGAIN
THANK YOU AGAIN VERY MUCH
THANK YOU AKI
THANK YOU EVERYONE
THANK YOU FOR BEING HERE
THANK YOU FOR BRINGING IT
THANK YOU FOR EVERYTHING
THANK YOU FOR HAVING ME
THANK YOU FOR HAVING US
THANK YOU FOR JOINING IN
THANK YOU FOR JOINING US
THANK YOU FOR LISTENING
THANK YOU FOR THAT
THANK YOU FOR THAT INCREDIBLE TALK WHICH CAN ONLY BE CALLED EPIC
THANK YOU FOR YOUR TIME AND I WOULD BE HAPPY TO ANSWER ANY QUESTIONS
THANK YOU GUYS
THANK YOU GUYS SO MUCH FOR REASONING
THANK YOU SEAN
THANK YOU SO MUCH
THANK YOU SO MUCH AGAIN GAVIN AND MATTHIJS
THANK YOU SO MUCH AISSATA
THANK YOU SO MUCH DAAN AND DIANE
THANK YOU SO MUCH FOR LISTENING
THANK YOU SO MUCH FOR YOUR ATTENTION
THANK YOU SO MUCH FOR YOUR TALK AND YOUR ANSWERS
THANK YOU STEFAN FOR THAT VERY VALIDATING TALK
THANK YOU TOO
THANK YOU VERY MUCH
THANK YOU VERY MUCH FOR JOINING ME TODAY
THANK YOU VERY MUCH FOR YOUR ATTENTION
THANK YOU ZAC
THANKS
THANKS AGAIN DYLAN
THANKS AGAIN FOR A GOOD PRESENTATION
THANKS AGAIN ZAC FOR THE GREAT PRESENTATION
THANKS AKI
THANKS EVERYONE
THANKS FOR ALL YOUR HELP
THANKS FOR ANSWERING
THANKS FOR HAVING US
THANKS FOR LISTENING IN
THANKS FOR THE INTRO
THANKS SO MUCH
THANKS SO MUCH FOR JOINING US
THANKS TARUN FOR QUITE THE INFORMATIVE TALK
THAT ACTUALLY THEN SURFACES A DIFFERENT ERROR MESSAGE ALL TOGETHER
THAT ARE BEGINNING TO LET US LEVERAGE GPU PERFORMANCE ADVANTAGES AND STILL LET US DO THE UI GRAPHICS THAT WE WOULD LIKE TO DO
THAT CAN HELP US
THAT CAPABILITY COMES WITH A TRADEOFF
THAT DIFFERENCE IS MEASURABLE AND IT LEAD TO KEY RECOVERY ATTACKS
THAT FINITE SET OF INPUTS AND OUTPUTS IS THE TOTAL OF THE CAPABILITIES OF THE SYSTEM
THAT FUNCTION OR THAT OR TO EVALUATE THAT CONSTANT
THAT I BELIEVE IS ANY PART IS A SEARCH FOR A PRESENTATION THAT CONVEYS A TARGET EXPERIENCE AND THE HUMAN ABILITY TO COMPREHEND SIMILARITY BETWEEN A REPRESENTATION AND A THING THAT IT AIMS TO REPRESENT IS AN ASTONISHING EXAMPLE OF ABSTRACT THINKING THAT COMES TO US SO NATURALLY
THAT I THINK IS QUITE AN IMPORTANT MESSAGE
THAT IMPLIES IT'S A BUG IN THE COMPILER
THAT INSTANCES OF THOSE TYPE ARE THE SAME
THAT IS A PERFECTLY GOOD VALUE BECAUSE IT RETURNS THE SAME AS BEFORE
THAT IS DOING THE CALLING
THAT IS OBVIOUSLY EVERYBODY HERE HAS THEIR IDEA OF WHY THEY WOULD USE RUST AND IN OUR CASE IT'S KIND OF THE SAME
THAT IS PRETTY GOOD
THAT IS PRETTY HARD RIGHT
THAT IS SO COOL
THAT IS STILL ON MY TO DO LIST
THAT IS THAT YOU CAN'T WRITE A SINGLE PROGRAM AND RUN IT ON EVERY GPU OUT IN THE WILD
THAT IS THE STD LIBRARY WORKS ACROSS MANY PLATFORMS
THAT IS TOO MUCH CODE TO PUT ON A SLIDE THAT'S THE RIGHT REACTION
THAT IS WHAT THIS LAST PART IS ABOUT FOREIGN FUNCTIONS
THAT IT'S SIGNIFICANTLY RESTRICTED
THAT JUST MIGHT TELL THE FEDS WHAT YOU TYPE
THAT MAKES OUR DECISIONS TRANSPARENT WHICH IS GOOD FOR THE GROWTH OF THE PROJECT AND ESTABLISHED A FORMAL PROCESS FOR REVIEWING CODE
THAT MAY COMPOUND EVEN FURTHER IF YOU WANT TO STORE GRAPHQL IN ANOTHER FORMAT
THAT MEANS GIVE YOURSELF SOME TIME
THAT MEANS THREE ENCODE STEPS ARE NECESSARY TO NEST ANOTHER FORMAT
THAT MIXING OF TYPES ACCOUNTS FOR A DISCONTINUITY BECAUSE LATER WE WILL USE TWO DIFFERENT VIEWS OVER THE SAME ALLOCATION WHICH IS PROFOUNDLY UNSETTLING
THAT OF COURSE ALSO IMPLEMENTS THIS
THAT PERSONAL EXPERIENCE COMBINED WITH DISCOVERING AN ALGORITHMIC REPRESENTATION I COULD USE I JUST HAD TO TRY IT OUT
THAT PROGRAM DOESN'T HAVE THE SAME SYNTAX THE COMPILER DOESN'T EVEN UNDERSTAND THAT PROGRAM
THAT REALLY FREES MY BRAIN TO FOCUS EXCLUSIVELY ON THE ALGORITHM DESIGN AND LOGIC FLOW AND I DON'T ENVISION MYSELF PROTOTYPING IN ANY OTHER LANGUAGE NOW
THAT SOUNDS FAMILIAR
THAT TAKES IT OFF OF THE STACK AND PUTS IT BACK IN OUR REGISTER
THAT THE CONSTRUCTER WHICH CONSTRUCTS THE DOG
THAT THE HELLO WORLD OF EMBEDDED IS SOMETIMES CALLED BLINKY
THAT THERE'S
THAT VALUE IS A COMPLETELY UNRELATED VALUE BASED ON THE PREVIOUS VALUE OF SOME UNRELATED REGISTERS
THAT WAS A GREAT TALK
THAT WAS AN EPIC
THAT WAS AN INCREDIBLE TALK AND YES LIKE YOU MENTIONED THE COMMUNITY AT THE END AND YOUR LOVE FOR IT AND YOUR BEING SUCH AN INTEGRAL PART OF IT AT LEAST TO ME SHOWS SO MUCH BECAUSE IT'S THAT SPIRIT LIKE YOU JUST HELD OUR HAND THROUGH ALL OF THAT
THAT WAS BRILLIANT
THAT WAS DEFINITELY THE MOST HELPFUL RESOURCE WHEN I WAS DOING RESEARCH INTO ALL OF THIS
THAT WAS EMBARRASSING
THAT WAS INCREDIBLE
THAT WAS REALLY INTERESTING
THAT WAS REALLY PROMISING
THAT WAS REALLY REALLY GREAT
THAT WE DO ON THE RUST ERROR HANDLING WORKING GROUP IS MORE TARGETING THAT SPECIFICALLY
THAT WILL BE VERY INTERESTING
THAT WOULD BE GREAT
THAT'S
THAT'S A BIT ABSTRACT
THAT'S A GREAT POINT
THAT'S A LITTLE BIT
THAT'S A LITTLE HARD FOR ME TO SAY TO BE HONEST
THAT'S A LOT MORE
THAT'S A LOT OF PIXELS
THAT'S A NICE AND STREAMLINED WAY TO SURFACE ERROR MESSAGES
THAT'S A PARTICULAR AVR MICROCONTROLLER
THAT'S A POP
THAT'S A POWERFUL BENEFIT
THAT'S A SIGNIFICANT LIMITATION WHEN DEVELOPING
THAT'S ACTUALLY THE ONE REASON WHERE THE COMPILER COULDN'T HELP ME
THAT'S ALL
THAT'S ALL SO THANK YOU FOR YOUR TIME
THAT'S AMAZING
THAT'S AN EXCELLENT INTRODUCTION
THAT'S CALLED THE PARSING PHASE
THAT'S EXACTLY THE APPROACH THAT THE INSTRUCTORS AT MY SCHOOL TAKE
THAT'S GOING TO RESTORE THAT VALUE TO THE
THAT'S IT
THAT'S IT AND THANK YOU AGAIN AND IT'S TIME FOR THE SURPRISE
THAT'S JUST PART OF BEING IN THE COMMUNITY AND PART OF GETTING TO PARTAKE IN THIS
THAT'S JUST RAW DATA
THAT'S MY PERSONAL EXPERIENCE WITH WRITING MY FIRST RUST PROGRAM
THAT'S MY TALK
THAT'S RIGHT
THAT'S SO COOL
THAT'S SUPER COOL
THAT'S THE MOST IMPORTANT THING
THAT'S THIS COMMON CURRENCY BETWEEN THE RUSTC FRONT END OR THE FRONT END FOR ANY COMPILER THAT MIGHT BE USING LLVM AND THE LLVM BACK END
THAT'S WHAT I'M TRYING TO AVOID BY HAVING THE SAMPLING MASK
THAT'S WHAT IT'S SUPPOSED TO DO
THAT'S WHERE WE LEARN A LOT ABOUT IT
THAT'S WHY ARTS PROGRAMMING AND SCIENCE ARE ACTUALLY MUCH CLOSER TO EACH OTHER THAN WE USUALLY PORTRAY
THAT'S WHY IT CHANGES ONE OF THE THINGS AND WHY I WOULD ADVISE TO START WITH THE STANDARD WHERE YOU HAVE MORE STABILITY SIMPLER CODE
THAT'S WHY MIRI IS CALLED MIRI BECAUSE IT'S AN MIR INTERPRETER
THE 0 AT THE BEGINNING IS A TAG BIT
THE ALGORITHMS AVAILABLE TO US AND THEIR LIMITATIONS INCLUDING THE ALGORITHM'S MINIMUM POSSIBLE COMPLEXITY ARE DETERMINED BY THE CHARACTERISTICS AND REPRESENTATIONS OF THE DATA
THE ANATOMY OF ERROR MESSAGES
THE ANIMATION COMPONENT SERVES AS DATA THE ENTITY SHOULD BE USING WHEN DETERMINING WHAT TO RENDERING THE SPRITERENDER COMPONENT WITH
THE ANIMATION LIBRARY FOR EXAMPLE AGAIN MUST HAVE A LOT OF WORK IN ORDER TO MAKE SURE THAT IT RUNS AS EFFICIENTLY AND SMOOTHLY AS THE JAVA IMPLEMENTATION RUNS
THE ANSWERS HAVE EVERYTHING TO DO WITH DATA DEPENDENCIES AND CHOICES MADE IN REPRESENTING THE DATA AS BYTES
THE APPROACH I HAVE TAKEN WITH OCHRE IS JUST TO CHOOSE A SMALL SUBSET
THE ASSEMBLER REFERENCED IS QUITE COMPLETE
THE AVR DOCUMENTATION GENERALLY IS PRETTY GOOD
THE BFF IS A TYPESCRIPT NODE JS PROCESS ITS ROLE IS TO FETCH DATA FROM WHEREVER THE DATA IS WHETHER IT IS AN API ANOTHER SYSTEM A THIRD PARTY API WHATEVER IT IS ITS JOB IS TO GO AND GET THE DATA
THE BIG GREEN BOX'S HEIGHT IS HOW LONG IT TAKES THE CPU TO ROUNDTRIP THE MESSAGE BACK FILE
THE BIGGEST DIFFERENCE TO THE CURRENT VERSION IS WE ARE PROVIDE COMPATIBILITY WITH CLICKHOUSE THAT INCLUDE COMPATIBILITY TO CLICKHOUSE NATIVE PROTOCOL ON DESKTOP STORAGE
THE BOOLEAN SHOULD NOT KNOW WHAT TO DO IF IT SEES A THREE ON ONE OR A ZERO
THE BOTTOM PART DEPICTS THE DATA WITH THREE F 64 SLOTS
THE BOTTOM ROW SHOWS EIGHT BITS FOR REFERENCE WHICH IS HOW MANY BITS ARE IN A BYTE
THE BUG HAS BEEN FIXED IN LLVM AND NOW I WANT TO CONTRIBUTE IT TO RUST
THE BUILDING BLOCKS FOR LOSSY COMPRESSION ARE PRESENT IN THE FORM OF TRUNCATING PLOTS
THE C INTEROPABILITY HAVING USED TENSORBASE THANKS TO THE ZERO OVERHEAD BUT IT HAS IT'S OWN PROBLEM
THE CADENCE IS MUCH HARDER THAN IT WOULD BE IN GO
THE CARGO IS USED BY THE COMPILER TO MAINTAIN THE STATE OF THE PROJECT
THE CHEAPEST START AT TEN OR 15 EUROS
THE CLANG CLANG COMPILER WHICH IS PART OF THE PROJECT IS THE C COMPILER ON THE MACINTOSH
THE CODE IS PARALLELISED AND DRAWING ON CPU IS QUITE SLOW AND IT JUST SO HAPPENS RECENTLY EMBARK HAS ANNOUNCED RUST ON GPU PROJECT
THE COMMUNITY THERE ALSO CARES A LOT ABOUT HAVING THEIR ERROR MESSAGES BE REALLY HELPFUL AND UNINTIMIDATING
THE COMPILER AND EXTREMELY GOOD ESPECIALLY WITH ERROR MESSAGES
THE COMPILER AND INSTRUCTIONS
THE COMPILER DOES A GOOD JOB OF GUIDING YOU AWAY FROM SORT OF UNSAFE WAYS OF DOING THINGS
THE COMPILER IS NOT COMPLAINING
THE COMPILER IS SOMETHING THAT TAKES A PROGRAM AS INPUT AND PRODUCES A PROGRAM AS OUTPUT
THE COMPILER IS YOUR TUTOR IN A WAY
THE COMPILER SEES THIS BEHAVIOUR OF THIS FUNCTION COMPLETELY DEPENDS ON THIS CONDITIONAL VALUE
THE COMPILER YOU MAY COMPARE WITH THE POPULAR JIT ENGINE BECAUSE IT CAN RUN ON ALMOST EVERYTHING
THE COMPONENTS FIRST
THE COMPUTATION CAN BE THOUGHT OF AS COMING FROM THERE
THE CONFIDENCE THAT I'M USING HOW DO THEY WORK SO WE CAN PUT THEM TO THIS
THE CONSUMERS OF THIS LIBRARY WILL PREFER THAT FEATURE FLAG
THE CORE IDEA HERE IS WHAT I CALL THE SEA OF PIPES WHICH UNIFY THE DATA AND THE CONTROL FLOW DEPENDENCIES IN THE GRAPH OF PIPES
THE CPU GPU RAM AND HARD DRIVE ARE ALL DATA DRIVEN COMPONENTS AND SUB SYSTEMS
THE CRANELIFT IS A LITTLE SLOW AS IT TIES ON THE NED
THE CURRENT LENGTH IS UNKNOWN UNTIL YOU SEARCH FOR AND FIND A TOKEN INDICATING THE END OF THAT ITEM
THE DASHES ARE USED AS THE SYNTAX FOR THE DOC
THE DATA DEPENDENCIES LIMIT PARALLELISM AND ADD COMPLEXITY INTO THE ENGINEERING THAT GOES INTO WRITING A PARSER
THE DATA DOES NOT APPEAR RANDOM IS A GOOD INDICATION SOME SORT OF COMPRESSION IS POSSIBLE
THE DATASET INCLUDES THINGS LIKE THE COUNTRIES NAME AND THE BULK OF THE DATA IS IN THE POLYGONS THAT DESCRIBE THE ORDER
THE DELTA IS AT A SWEET SPOT AND NOT THE WORST AT ANY CATEGORY
THE DESK IN FRONT OF THEM THAT'S COVERED IN THE PAPER WORK THEY'RE CURRENTLY WORKING ON IS SOMETHING LIKE THE REGISTERS
THE DETAILS ARE NOT RELEVANT I'M NOT GOING TO GET INTO IT
THE DIFFERENCE BETWEEN THE TWO CAN BE THE DIFFERENCE BETWEEN HAVING DECODING BE A MAJOR BOTTLENECK OR INSTANT
THE DIFFERENCE IS STARKER THAN YOU MIGHT THINK AND NOT JUST BECAUSE OF THE EXTRA BOILERPLATE CODE OR IT BEING JAVASCRIPT OR THE CACHE FROM FLOAT TO INT WERE TYPED ARRAYS BUT MOSTLY BECAUSE OF AGAIN DATA DEPENDENCIES
THE ELEMENTS WHICH COULD BE PRESENT IN THE OPTIONS ARRAY ARE TCP OPTIONS
THE ENGINE BLOCKS ARE CARVED FROM LARGE BLOCK OF METAL AND THE HUB CAPS ARE CREATED THROUGH METAL FABRICATION PROCESSES
THE EPILOGUE IS IN THE WRONG ORDER
THE EXISTING SCIENTIFIC LANDSCAPE WE HAVE PYTHON IS SORT OF THE LINGUA FRANCA OR THE LANGUAGE THAT EVERYBODY SPEAKS
THE FACIAL FEATURES ARE CAPTURED SO MUCH MORE PRECISELY WITH CANNY OR SOBEL
THE FILE FOLDER OPEN
THE FIRST AND THE REST FOR THE CONS WHILE EMPTY DOESN'T HAVE ANY DATA AVAILABLE
THE FIRST ASPECT IS YOU TAKE THE SHAPES
THE FIRST BIT IS TAKEN FOR THE TAG BIT USING TWO BITS FOR STORING THOSE FOUR VALUES
THE FIRST BOX CONTAINS A 0 THE NEXT TWO BOXES ARE BLANK
THE FIRST DOCUMENT WAS A LARGE FLOWCHART EXPLAINING MY IDEAS FOR WHAT PROGRESSION THROUGH THE GAME LOOKED LIKE
THE FIRST ELEMENT OF THIS TUPLE IS A BORROWED ARRAY OF BYTES WHICH FOR PROTOCOL TESTING WOULD BE AN INCOMING PACKET OF SOME SORT
THE FIRST EXAMPLE IS A BLACK BOX MODEL
THE FIRST EXAMPLE WILL BE IN PARSING GRAPHQL AND THE SECOND IN BUFFERS AND THE THIRD IS THE USE OF COMPRESSION IN THE TREE BUF FORMAT
THE FIRST FACTOR THAT MADE OUR COLLABORATION SUCCESSFUL IS OUR COLLABORATIVE CODING PRACTICES
THE FIRST IS A CONFIGURE ENVIRONMENT
THE FIRST MVP WAS FOR SPACE SHOOTER AS A SHOWCASE GAME
THE FIRST NON BIT STRING WE ENCOUNTER IN TCP HEADER IS OPTIONS WHICH IS AN ARRAY TYPE
THE FIRST ONE IS PARSING
THE FIRST ONE IS TEXTURE SYNTHESIS WHERE I GOT INTRODUCED TO RUST
THE FIRST ONE IS THAT SOME PEOPLE USE UNSAFE BECAUSE THEY'RE VESTED IN PERFORMANCE
THE FIRST ONE IS THE SUBTLE CRATE WHICH IF EVER YOU NEED TO DO SOME STUFF IN CONSTANT TIME USE THIS CRATE
THE FIRST ONE IS THERE IS A PUSH FOR NATIVE IMPLEMENTATION OF THE NETWORKING TYPE SO THE RUST STANDARD LIBRARY DOESN'T LEWIS LIPSE ANY MORE BUT DIRECTLY OPERATES WITH SYSTEM CALLS
THE FIRST ONE WE'VE GOT IS THAT THIS IS ALL VERY COMPLEX
THE FIRST PATTERN WE MIGHT PICK UP ON IS MOST OF THE MOVES ARE BEING MADE IN CERTAIN AREAS OF THE BOARD AND MANY ARE ON THE SIDES AND CORNERS
THE FIRST POINT I AM TRYING TO MAKE TODAY IS THAT AT EVERY LEVEL SERIALIZATION DOESN'T JUST UNDERLIE EVERYTHING WE DO BUT IS IN SOME SENSE THE MEANS AND ENDS OF ALL PROGRAMS
THE FIRST RENDITION IS ONLY 3 14
THE FIRST SECTION DEFINES OUR INTERFACES
THE FIRST STATEMENT WAS THAT THE DATA REPRESENTATION IS AN ESSENTIAL FACTOR IN DETERMINING THE SYSTEM'S PERFORMANCE
THE FIRST THING IS THAT UNSAFE IS A CONTROVERSIAL TOPIC IN OUR COMMUNITY
THE FIRST THING THAT HAPPENS IS THE ARGUMENTS TO THE FUNCTION ARE SERIALIZED TO THE STACK
THE FIRST THING WE DID WHEN APPLYING OUR CUSTOM DESIGN DELTA COMPRESSION METHOD WAS TO SEPARATE THE X AND Y COORDINATE STORAGES
THE FIRST THING YOU WANT TO DO WHEN YOU INTRODUCE STUDENTS TO A NEW PROGRAMMING LANGUAGE IS TO TEACH THEM
THE FIRST THINGS THAT HI LEARNED IS JUST OWNERSHIP AND BASIC SYNTAX
THE FIRST TIME YOU WILL SEE A MOTOR MOVE BECAUSE YOU DECIDED IT YOU WILL BE HOOKED
THE FIRST TWO ARE LIKE RUST FUNCTIONS THAT ARE IN THE STANDARD LIBRARY
THE FIRST TWO POINTS HAVING COMPONENTS THAT WERE BLOATED AND REDUNDANT DATA MADE IT DIFFICULT TO KEEP TRACK OF WHAT DATA A COMPONENT WAS RESPONSIBLE FOR
THE FIX IS CONSTANT TIME CODE OR TO BE MORE PRECISE DATA INVARIANT CODE WITH THE TIME IT TAKES TO EXECUTE THE CODE DOESN'T DEPEND ON THE INPUT
THE FORMAT USED BY VERTEX BUFFERS HAS A DIFFERENT SET OF CAPABILITIES OF JSON AND THAT CAN'T BE WORKED AROUND WHEN CONSUMING THE DATA
THE FUNCTION THAT'S BEING INTERRUPTED DOESN'T KNOW THAT IT NEEDS TO SAVE THE WORKING REGISTERS
THE FUNCTION WE WILL WRITE IS A STRIPPED DOWN VERSION OF WHAT YOU MIGHT NEED TO WRITE A SINGLE VERTEX TO A VERTEX BUFFER FOR A GAME
THE GAME CONTAINED LARGE COMPONENTS WITH REDUNDANT DATA
THE GAME HAS FOUR CONSUMABLE DROPS
THE GENERAL RULE FOR THIS MVP WAS THINGS ONLY COULD BE IN THE SHOWCASE GAME TO THE POINT WHERE THEY MADE SENSE FOR THE GAME TO SHOW OFF THE AMETHYST ENGINE
THE GOAL IS TO HAVE MORE THAN ONE WAY TO CONTRIBUTE CODE ARTWORK IDEAS FOR ITEMS AND EVEN DOCUMENTATION
THE GOAL OF THE GAME IS TO SURVIVE LEVELS BY DESTROYING ENEMIES COLLECTING CONSUMABLES BUYING ITEMS AND DEFEATING THE FINAL BOSS
THE GOOD NEWS IS THAT MIRI CAN ACTUALLY RUN YOUR PROGRAM IN A PARTICULARLY INTERESTING WAY
THE GOOD NEWS IS THAT WE DON'T HAVE TO START FROM SCRATCH
THE GOOD PARTS
THE GRAPHQL STRING VALUE IS UNICODE BUT THE WAY THAT GRAPHQL EMBEDS STRINGS IS BY PUTTING QUOTES AROUND THEM
THE GREEN BOX IS GEO JSON AND THE BLUE BOX IS TREE BUF
THE HEIGHT CORRESPOND DO IS THE VALUE OF THE BYTE
THE HTTP HEADERS NEST FURTHER AND OTHER SERIALIZATION FORMATS BEING THE PAYLOAD THE FORMAT WHICH IS SPECIFIED BY THE HEADERS
THE HTTP REQUEST COMPRISES MULTIPLE SERIALIZATION FORMATS
THE IMAGES HERE HIGHLIGHT THE PROPERTIES THAT DEFINE MOTION BEHAVIOR AND WE CAN NOW MOVE THEM INTO THEIR OWN COMPONENT
THE IMPROVEMENTS ARE SIGNIFICANT
THE INSTRUCTORS WANT STUDENTS TO WALK AWAY FROM THE COURSES WITH GOOD HABITS
THE INTENT OF THE DOCUMENTS WAS FOR MICAH TO USE AS A REFERENCE GETTING FAMILIAR WITH THE GAME
THE INTERESTING THING IS THAT IF WE ONLY LOOK AT THE SOURCE CODE IN RUST IT LOOKS LIKE SOMETHING THAT LIKE IT LOOKS LIKE CODE THAT FEELS COMPLETELY LIKE THIS COULD BE OR SHOULD BE IMPLEMENTED IN CONSTANT TIME
THE ISSUE IS IN THE WAY THAT GRAPHQL NESTS ITS SERIALIZATION FORMATS
THE JIT COMPILATION THE ADVANTAGE IS WE CAN EMBED THE RUNTIME INFORMATION IN THE CODE WHICH WE HAVE MORE OPTIMIZATION FOR COMPILER WHICH CANNOT BE DONE ON OAT COMPILATION
THE LAST FIELD IN THE PACKET IS THE PAYLOAD WHICH WE CAN PROCESS RELATIVELY EASILY AS A STRIPPED OUT BIT STRING
THE LATEST NVIDIA CARDS HAVE A STAGGERING 10 496 CUDA CORES AND THAT'S NOT EVEN COUNTING TENSOR CORES
THE LIBC DOCUMENTATION FOR AVR ALSO CONTAINS A LOT OF NUGGETS THAT ARE VERY USEFUL FOR ILLUMINATING HOW THINGS ACTUALLY WORK ON THE AVR PLATFORM
THE LIBRARY ECOSYSTEM MATURITY HAS BEEN ACTUALLY GOOD ENOUGH FOR US BUT AT THE BEGINNING IT WAS A BIT DIFFICULT FOR US TO GAUGE
THE LOGGER IS IMPLEMENTATION THAT ALL THE FORMATS WOULD SEND THE EVENTS TO
THE LOGGING IMPLEMENTATION IS IN THE MAIN FILE
THE MAIN DISADVANTAGE OF THIS APPROACH IS OF COURSE THAT IT IS NOT STANDARD AND CAN BE CURRENTLY IT REQUIRES MANUAL IMPLEMENTATION
THE MAIN DRIVEN DESIGN IS ONE OF THE MOST IMPORTANT CONCEPTS WE VALUE IN THE DEVELOPMENT OF ENTERPRISE SOFTWARE AND IT IS A COIN TERMED BY ERIC EVANS IN THIS 2003 BOOK EMPHASIZING THE IMPORTANCE OF FOR SOFTWARE DEVELOPERS TO UNDERSTAND THE REAL WORLD DOMAIN AND TRY TO MODEL AND EXPRESS IT IN SOFTWARE
THE MAIN REASON IS RUST LIKES THE MEMORY MODEL LIKE JAVA
THE MAIN REASON IS WE WANT TO REUSE MODERN LOW LEVEL COMPILATION
THE MAIN THING SO LOOK FOR HERE IS THE API PERFORMANCE BECAUSE WE WANT TO MAKE SURE THAT MOCK FUNCTIONS THAT WE CALL HAVE THE EXACT SAME INTERFACE AS YOUR REAL CODE
THE MECHANICS TO ENABLE AND WRITE IN AN ELEGANT WAY TO IR
THE MEMORY IS A BIT LIKE A FILE CABINET THAT HOLDS THE PAPERWORK THAT THEY NEED THEY NEED TO HAVE ACCESS TO BUT THEY DON'T NEED IT IMMEDIATELY AT HAND
THE MESSAGE PACK FILE IS MORE THAN 17 TIMES AS LARGE AS THE TREE BUF FILE AND TAKES MORE THAN TWICE AS LONG TO SERIALIZE AND DE SERIALIZE
THE MONEY IS USED TO PURCHASE ITEMS FROM THE STORE
THE MOST ADVANCED USER SYSTEM TRAITS AND THE TYPE SYSTEM
THE MOST CRUCIAL PART IS ACTUALLY THE COMPILING OF THE CODE INTO WEBASSEMBLY AND THE RUST COMPILER HAS GOT US COVERED THERE
THE MOST IDIOMATIC CODE THE SAFE CODE ALL THE MOST PERFORMANT CODE
THE MOST IMPORTANT
THE MOST IMPORTANT PART IS THAT ALTHOUGH THESE TRICKS MIGHT WORK AT THE MOMENT THEY ARE NOT GUARANTEES
THE MOST INTIMIDATING PART IS TO GET STARTED AND ORDER STUFF FROM THE INTERNET
THE NESTING REFLECTS THE SYSTEM'S ARCHITECTURE BECAUSE MANY LAYERS EXIST TO ADDRESS CONCERNS THAT MANIFEST AT THAT PARTICULAR LAYER OF ABSTRACTION OF THE COMPUTER
THE NEXT ASPECT AFTER ENUMS THAT WE HAVE UTILIZED EXTENSIVELY IS USING PHANTOM DATA TYPES AS MARKERS FOR COMPILE DATA TYPE CHECKING
THE NEXT PART OF ABSTRACT CLASSES IS DEFINING SHARED DATA
THE NEXT SESSION IS ALL ABOUT CALCULATING OFFSETS OF WHERE THE DATA LIVES IN THE BUFFER
THE NEXT STEPS THIS PROJECT IS STILL ONGOING AND THERE ARE MORE DIRECTIONS THAT THIS RESEARCH CAN GO IN
THE NEXT THING THE INSTRUCTORS USUALLY INTRODUCE IS JAVA ABSTRACT CLASSES
THE NEXT THING WE ARE GOING TO DO IS TO POSSIBLY RESIZE THE BUFFER
THE NEXT THING WE KNOW WITH THE COMPRESSION IS WE APPLIED A TYPE AWARE ARRANGING THE DATA
THE NICE THING ABOUT PARSER COMBINATORS YOU CAN HAVE A
THE NICE THING FROM THERE IS WE CAN KIND OF GO AHEAD AND DO A LITTLE BIT OF SPELUNKING INSIDE OF RUST C TO KIND OF UNCOVER BY PROCESS OF ELIMINATION LIKE IS THIS A QUESTION OF TECHNOLOGY
THE OBSERVATION THAT LOCAL DATA IS RELATED AND THE TYPE SPACE IS NOT TO BE USED IS NOT SPECIFIC TO GO
THE ONLINE WORK BOOK FOR SPACE SHOOTER IS A WORK IN PROGRESS
THE ONLY DIFFERENCE BETWEEN THIS MVP AND THE SHOWCASE GAME MVP IS THE GENERAL RULE FOR THIS DOCUMENT IS MORE CONTENT TO MAKE THE GAME AS FUN AS POSSIBLE RATHER THAN JUST SHOWING OFF THE ENGINE
THE ONLY DIFFERENCE IS THE CODE GENERATION STAGES DON'T RUN SO WE DON'T GET TO TALK WITH LLVM
THE ONLY PART ABOUT THIS OPEN64 FUNCTION THE OPEN64 FUNCTION IT'S A RUST FUNCTION IT'S AN LINUX SYSTEM USED TO OPEN A FILE
THE ONLY THING THAT IS UNSAFE IS READING FROM THE POINTER CALLING THE REFERENCE STAR OPERATOR
THE ONLY THING THAT'S DIFFERENT WITH RUST IS YOU SHOULD KEEP YOUR STEPS
THE ONUS ON THE CODE REVIEWER OR YOURSELF TO LOOK AT WHERE POTENTIALLY DANGEROUS THINGS ARE HAPPENING
THE ORDER AND LAYOUT OF THE ARGUMENT OR THE FILE FORMAT IF YOU WILL IS CALLED THE CALLING CONVENTION
THE ORDER FOR THE LIBRARY IS PRETTY SMALL
THE ORDER IN WHICH WE GENERATE THESE CUSTOM TYPES AND PARSERS IN THE RUST OUTPUT FILE IS DETERMINED BY DEPTH FIRST SEARCH
THE OTHER CONTEXT I DO A LOT OF MY DEVELOPMENT IN IS HIGH PERFORMANCE WEB DEVELOPMENT
THE OTHER RESOURCE THAT I FOUND TO BE INCREDIBLY HELPFUL IS A
THE OTHER THING IS THAT IT'S A PRODUCTIVE MODERN PROGRAMMING LANGUAGE WITH A LOT OF DEVELOPER CONVENIENCES
THE OTHER TWO STORAGES IT READS FROM ARE THE ANIMATION AND SPRITERENDER COMPONENT STORAGES
THE OVERALL PROTOCOL DATA UNIT IS A TCP HEADER WHICH IS A STRUCT TYPE IN OUR CUSTOM NETWORK PACKET REPRESENTATION SYSTEM
THE OVERALL SCORE HARD PLAYMATEER BECAUSE WHERE GZIP WINS IS IN THE DIFFICULTY CATEGORY
THE OXYGEN IN THE AIR REACTS WITH IRON TO FORM THE WEAKER SUBSTANCE WE KNOW AS RUST
THE PARSER FUNCTION ITSELF TAKES A DEFINED NUMBER OF BITS FROM THE INPUT BYTE ARRAY IN THIS THIS CASE IT WILL TAKE SIXTEEN BITS AND THEN ASSIGNS THE VALUE OF THOSE TAKEN BITS TO THE CUSTOM RUST TYPE AS NEEDED
THE PAYLOAD MAY NEST TO UNICODE WHICH MAY NEST TO GRAPHQL WHICH ITSELF NEST TO MANY DIFFERENT SUBFORMATS AS DEFINED BY THE SPEC
THE PERFORMANCE WILL BE ABOUT AS BAD AS THOSE OTHER GARBAGE COLLECTED LANGUAGES BECAUSE OF ALL THE EXTRA ALLOCATING AND COPYING THAT NECESSARILY ENTAILS
THE PERIPHERALS ARE THE INTERFACE TO THE OUTSIDE WORLD
THE PERSONAL WEAKNESS TO READ A LOT ABOUT LANGUAGES BEFORE I USE THEM
THE PICTURE ON THE LEFT IS A GENUINE SAMPLE OF OUR GENERATED TCP PARSER CODE FROM OUR MODIFIED TCP DOCUMENT
THE PIECES WE MINUTE MIGHT BE DIFFERENT BUT THE PIECES OF SEARCH IN ART PROGRAMMING SCIENCE ARE SIMILAR
THE PREDICTION WORKS GREAT FOR TEXT
THE PROBLEM OF AGE IS STILL TRADITIONAL
THE PROBLEM WITH SUBTRACTING IS THAT THE X AND Y COORDINATES FROM THE DATA ARE INDEPENDENT BUT INTERWEAVED IN THE DATA
THE PROBLEM WITH THAT IS THAT DATA DEPENDENCIES LIMIT PARALLELISM
THE PROCESS AS BRUTE FORCE AS IT WAS REMINDED ME OF MY OWN EXPERIENCE DURING LIFE DRAWING CLASSES HAVING TO TRANSLATE WHAT I SEE INTO A SET OF DISCRETE MOTIONS WITH A PENCIL OR A CHARCOAL
THE PROGRESS OF LEVELS UNLOCKING CHARACTERS BOSSES
THE QUALITY OF THE PREDICTION IS THE MANUFACTUREER DETERMINING HOW WELL THE COMPRESSION WORKS
THE REASON THAT 24 IS DOWN BELOW AND R0 R1 AND STATUS REGISTER ARE UP ABOVE IS BECAUSE REGISTER ZERO AND 1 ARE THE CALLER SAVED REGISTERS
THE REASON WE WANT TO USE RUST IS WE HAVE ALL THESE TYPES AND ALL THESE NICE CHECKS IN THE COMPILER THAT ALLOW US TO MAKE OUR CODE THAT IS EASIER TO WRITE SECURE CODE
THE REASON WHY I MADE IT TO THE ALWAYS PROBABILISTIC IS I DON'T WANT TO EXCLUDE ANY HAPPY ACCIDENTS
THE REASONS FOR THIS ARE EASY TO OVERLOOK SO I WILL GO OVER EACH
THE RED BOX IS WHAT WE GET IF WE OPT INTO THE LOSSY FLOAT COMPRESSION WHICH ALLOWS US TO SPECIFY HOW MUCH PRECISION IS NECESSARY TO REPRESENT THE DATASET
THE RESOLUTION OF SCREENS ARE GOING UP
THE RESOURCES ARE AVAILABLE IN JAPANESE AS WELL
THE RESULT APPROXIMATES A HAND ROLLED FILE FORMAT THAT GENERALLY UNDERSTANDS YOUR DATA
THE RESULT IS OUR GO GAME COMPRESSS TO LESS THAN HALF THE SIZE OF WRITING THE DATA OUT USING ONE BYTE PER THE PREDICTION IS MORE ACCURATE WHILE BEING COMPUTATIONALLY EASIER TO INTRODUCE
THE RESULTING FILE COMPRESSES DOWN TO LESS THAN ONE TENTH THE SIZE WITHOUT SACRIFICING SPEED
THE RISKS OF FELINE
THE RUST COMMUNITY'S VERY WELCOMING AND ONE OF THEIR CORE VALUES IS TO PROVIDE A SAFE FRIENDLY AND WELCOMING ENVIRONMENT
THE RUST CORE LIBRARY
THE RUST IMPLEMENTATION HAS AN API VERY MUCH LIKE SATURDAY
THE RUST PROGRAMMING LANGUAGE AND SHARE MY EXPERIENCE USING IT TO DEVELOP ENTERPRISE SOFTWARE
THE RUST SOURCE CODE FOR OUR PROGRAM
THE RUST STRUCTURES ARE REFLECTED IN THE TYPESCRIPT LAYER IN FACT
THE SAFETY BENEFITS OF RUST HELP YOU LEARN
THE SANDBOXED ENVIRONMENT IS NOT SOMEONE ELSE'S MACHINE OR SERVER BUT IT'S YOUR OWN WEB BROWSER AND THIS SANDBOX IS SECURED BY DEFINITION
THE SAVING AND RESTORING OF REGISTERS
THE SECOND DIFFERENCE IS THAT IN AN EMBEDDED CONTEXT WE'RE WORKING IN IT'S A NO STD ENVIRONMENT
THE SECOND MVP WAS FOR SPACE SHOOTER AS A FULLY RELEASED GAME
THE SECOND POINT IS THAT DATA REPRESENTATION IS AN ESSENTIAL FACTOR IN DETERMINING THE ENGINEERING EFFORT REQUIRED TO PRODUCE THE SYSTEM
THE SECOND PROJECT IS CALLED KITTIWAKE WHICH IS A GAME LIKE ENVIRONMENT WHERE WE EXPLORE A FEELING OF CO CREATION WITH AN EXAMPLE BASED ALGORITHM WHICH IS EMBODIED INTO THIS LITTLE CREATURE
THE SECOND STEP COMPOSITING ON THE LEFT HERE GPUS ARE REALLY GOOD AT IT
THE SENSOR HAS A TRIGGER AND AN ECHO
THE SEQUENCE WE WALKED THROUGH A FEW MINUTES AGO
THE SET OF GPUS AVAILABLE IN CONSUMER HARDWARE ARE A GOOD FIT FOR UIS
THE SETS ARE SIMILAR ENOUGH THAT WE CAN'T ATTRIBUTE IN THE RESULTS TO A DIFFERENCE IN CAPABILITIES
THE SMALLEST SUBSET OF GPU FEATURES THAT ARE GOING TO BE AVAILABLE PRETTY MUCH ANYWHERE
THE SOLUTION IS THROUGH THE USE OF AN EVENT CHANNEL
THE SOMEWHAT MORE PHYSICAL VIEW OF THE STACK I LIKE TO THINK OF AS A STALACTITE
THE STABLE RELEASE HAPPENS EVERY SIX WEEKS AND BETA HAPPENS BEFORE EVERY STABLE RELEASE AND THE NIGHTLY IS DAILY
THE STATE OF THE ART
THE STRING VARIANT JUST CONTAINS TO STRING TYPE REQUIRING ALLOCATING AND COPYING
THE STRONGER THE DIRECTION THE MORE INFLUENCE IT HAS ON A BRUSHSTROKE THAT MIGHT BE PLACED IN THAT REGION
THE STYLE IS ORTHOGONAL TO THE PERFORMANCE SO USE IT CORRECTLY
THE SUBTLE CRATE DOES THAT AND THAT'S WHY I RECOMMEND THAT CRATE
THE SYSTEM IS A WAY TO KNOW WHAT SPRITE IS IN EACH GAME CYCLE
THE SYSTEM OPERATES AT PEAK EFFICIENCY ONLY WHEN THE COMMUNICATION BETWEEN COMPONENTS IS SATURATED WITH EFFICIENTLY REPRESENTED DATA
THE SYSTEM THAT THE COMPUTER IS A PART OF INCLUDES OTHER COMPONENTS ATTACHED TO THE COMPUTER COMPONENTS LIKE MICE KEYBOARDS SPEAKERS SCREENS AND NETWORK CARDS SEND DATA TO AND FROM THE COMPUTER THROUGH WIRES LIKE IN THIS PICTURE
THE TECHNOLOGY IS ALL THERE TO ACTUALLY MAKE IT HAPPEN
THE THING IS THAT YOU DON'T HAVE A LOT OF THE TYPE OF INFORMATION YOU HAVE WHEN YOU'RE INTERPRETING THE MIR
THE THING IS WE DON'T REALLY HAVE ACCESS TO DEPENDENCIES ON THE RUST PLAYGROUND EITHER BECAUSE RUST PLAYGROUND HAS A LIMITED SET AVAILABLE TO US BECAUSE IT'S AN ISOLATED ENVIRONMENT AND THAT'S AN EXPECTED THING BECAUSE THE RUST PLAYGROUND SUITS THE CODE ON THEIR SERVER AND THEY WANT TO MAKE SURE THAT THE CODE IS NOT MALICIOUS AND THEY LIMIT THINGS LIKE INPUTS AND OUTPUTS AND LOADING THE EXTERNAL DEPENDENCIES
THE THING WITH ESPECIALLY SYNC THINGS GET COMPLICATED QUICKLY
THE THIRD POINT WAS THAT DATA REPRESENTATION IS AN ESSENTIAL FACTOR IN DETERMINING THE SYSTEM'S CAPABILITIES AS A WHOLE
THE TIME IS LIMITED
THE TOP PORTION IS A DESCRIPTION INCLUDING THE NAME PAUSE X Y AND Z FOR A VERTEX POSITION AND RB AND G COLOR CHANNELS
THE TRACE FILES CAN REPRESENT MEMORY INSIDE THE PROCESSER
THE TRAIT TYPES
THE TRICK IS THAT GZIP IS NOT BY ITSELF A SERIALIZATION FORMAT
THE TRIGGER TURNS IT ON AND SENSES THE SOUND WAVE
THE TYPING GUARANTEES OFFERED BY RUST WILL HELP US ENSURE WE GET THE MACHINE READABLE SPECIFICATION DOCUMENT AND IN OUR NETWORK PACKET REPRESENTATION SYSTEM
THE UNIT TEST AND INTEGRATION TEST
THE UNIT TEST FOR THE INTEGRATION TEST YOU HAVE TO PUT THEM IN THE TEST DIRECTORY ESPECIALLY BECAUSE YOU WANT TO BE ABLE TO TEST YOUR CODE LIKE AN EXTERNAL AND BINARY USES
THE USER KNOWS BEST THEIR PLATFORM AND PERFORMANCE THINGS
THE VALUE IS A BYTE BUT THE OFFSET THE OFFSET OF THE PREVIOUS FIELD PLUS 1 TIMES THE SIZE OF AN F THIRTY TWO IN BYTES
THE VALUE OF OUR NUMBER ON IT
THE VALUE OF THE FIELD IN THIS ASCII DIAGRAM IS A BIT STRING
THE VERY HIGHEST ADDRESS AND GROWS DOWNWARDS
THE WAY IT WORKS IS YOU HAVE A CPU PRE PROCESS
THEN BOTH OF THESE END OPERATIONS WILL MAKE SURE THAT THIS VALUE WITH ZERO AND THIS VALUE WAS ZERO AND BOTH OF THESE OPERATIONS WOULD BE A NO OP AND THEN A KEEPS THE SAME VALUE
THEN DO SOME EXERCISES AND THEN GO BACK TO RUST BY EXAMPLE WHERE YOU HAVE MORE CODE
THEN I'M GOING TO TALK BIT ABOUT FUNCTIONS
THEN IT TRANSFORM TO AN IR WHICH THE IR IS LAID
THEN IT'S QUITE LIKELY THAT IT WILL WORK OUT
THEN LLVM IS NOT ABLE TO REASON ABOUT WHAT HAPPENS INSIDE OF AN ASSEMBLY DIRECTIVE
THEN ONCE A PULL REQUEST HAS BEEN SUBMITTED AS A POTENTIAL FIX FOR THAT ISSUE WE COULD MOVE THE IMPLEMENTATION DISCUSSIONS TO THERE
THEN ONLY IF THIS CONDITIONAL VALUE WAS TRUE IT WILL X AGAIN WITH B
THEN SOME OF THE CHALLENGES THAT WE RAN INTO I WOULD LIKE TO GO THROUGH REALLY QUICKLY
THEN THE HIR IS LOWERED TO ANOTHER REPRESENTATION INTO THE MIR PRESENTATION BUT THIS IS A MID LEVEL REPRESENTATION MIR
THEN THE SYSTEM CAN READ THE DATA FROM THE EVENT MESSAGE AND USE IT IN THE SYSTEM
THEN THIS AST IS TRANSFORMED AND PRODUCES A HIGH LEVEL INTERMEDIATE REPRESENTATION OR HIR
THEN THOSE PINS CAN BE DOWNGRADED
THEN WE ARE RUNNING THE PROGRAM USING THE R COMMAND
THEN WE DECLARE IMMUTABLE TIMER IMMUTABLE PIN
THEN WE HAVE LIKE FOUR FUNCTIONS THAT ARE SPECIFIC FOR UNIX LIKE PLATFORMS SO THOSE ONLY RUN ON LINUX MACOS
THEN WE HAVE LIKE THE SAFE COUNTERPOINT OF THIS FUNCTION SO WE GUARANTEE THAT
THEN WE HAVE TO MANAGE AN EVENTUAL ERROR WITH THE HARDWARE SO IF WE HAVE WAITED FOR MORE THAN 50 000 TICKS IT MEANS THAT WE HAVE WAITED FOR MORE THAN 200 MILLISECONDS SO THIS IS PROBABLY AN ERROR SO WE NEED TO USE TO EXIT THE LOOP SINCE RUST IS ALLOWING US TO NAME LOOPS WE CONTINUE TO WORK WE CONTINUE WITH THE OUTER LOOP
THEN WRITTEN TO THE EVENT CHANNEL IN THE SOURCE SYSTEM
THEN YOU CAN TAKE A LOOK AT THE CODE PROVIDED IN THIS EXAMPLE AND THIS CODE CONNECTS TO OUR REDIS LIKE SERVER AND SENDS A KEY TO HELLO WITH VALUE WORLD AND GETS THE REQUEST WITH THE SAME KEY AND VERIFIES THAT IT HAS THE EXPECTED VOLUME
THEN YOU HAVE SOME CODE
THERE ARE 13 UNIQUE ITEMS
THERE ARE A FEW MORE QUESTIONS BUT WE'RE REALLY RUNNING OUT OF TIME
THERE ARE A LOT OF DIFFERENT APPROACHES TO DOING SO
THERE ARE A LOT OF TINY THE SHIMS LABEL THERE ARE TINY PROBLEMS HERE
THERE ARE A LOT OF TRADE OFFS YOU CAN DO THERE
THERE ARE ALSO NOT SUCH GOOD NEWS AND IT'S THAT UNSAFE IS SUPER IMPORTANT PART OF OUR ECOSYSTEM
THERE ARE ALSO SOME HONORABLE MENTIONS
THERE ARE ANIMATIONS THREE D BACKGROUNDS AND A WORK IN PROGRESS BOSS IN THE GAME
THERE ARE ARGUMENTS ON SPECIFIC TESTS
THERE ARE BETTER WAYS TO DO THIS WHICH WE WILL RETURN TO LATER
THERE ARE DOWNSIDES TO ARRAYS OF FIXED WIDTH ELEMENTS
THERE ARE GOOD RESOURCES ONLINE FOR CARGO AND BOOKS FOR EVERYTHING
THERE ARE GREAT RESOURCES ON IT FOR SURE
THERE ARE LIKELY SIGNIFICANTLY MORE FIELDS YOU WOULD WANT TO PACK INTO A VERTEX INTO REAL GAME BUT THIS IS GOOD FOR ILLUSTRATION
THERE ARE MANY CAPABILITIES THAT YOU CAN DESIGN INTO REPRESENTATIONS THAT WE DID NOT EXPLORE TODAY
THERE ARE MANY DETAILS BUT I WILL JUST COVER THE ONES I WILL SHOW IN THE CODE
THERE ARE MANY PROPERTIES OF DIFFERENT TYPES
THERE ARE MANY WAYS ONE MIGHT IMPLEMENT THIS SEARCH
THERE ARE NESTED OBJECTS ARRAYS AND THOUSANDS OF OTHER ENTITIES LIKE THIS ONE BUT WITH A CARDINALITY IN THE DATA THAT REFLECTS A REAL WORLD DISTRIBUTION OF VALUES
THERE ARE NUMBERS BOOLEANS AND STRINGS
THERE ARE ONLY TWO THAT WE WILL TALK ABOUT TODAY
THERE ARE POINTERS THAT LET'S SAY ARE POINTING TO SOMETHING THAT DOESN'T BELONG TO US
THERE ARE POINTS EVERYWHERE AND SEEMS TO BE NO VISUAL PATTERN AT ALL
THERE ARE SCHEMATICS THAT FOLLOW
THERE ARE SEVERAL BASIC TYPES THAT WE CAN IDENTIFY FROM PROTOCOL STANDARD DOCUMENTS AND WE WILL TAKE A TCP HEADER TO DEMONSTRATE THIS
THERE ARE SEVERAL OTHER OUTSTANDING AVR ISSUES
THERE ARE SIMILAR DEVICES THAT HAVE ONLY 512 BYTES OF PROGRAM MEMORY
THERE ARE SIX FUNCTIONS HERE
THERE ARE SOME EXCEPTIONS
THERE ARE SOME LIMITATION THAT IS MIRI HAS
THERE ARE SOME QUESTIONS POPPING UP FOR USE CASES AND WHAT APPLICATIONS OF USE OF TERMINUSDB AT THE MOMENT
THERE ARE SOME TRAITS THAT ARE MARKED AS UNSAFE TOO
THERE ARE THREE BOXES ON THE TOP ROW
THERE ARE TWO MAIN EXAMPLES IN THE WILD
THERE ARE TWO MAIN REASONS
THERE ARE TWO PARTS TO THIS PROBLEM AN LLVM PART AND A RUST PART
THERE ARE TWO SERIALIZATION STEPS
THERE ARE TWO TRENDS OVER THE PAST 15 20 YEARS OR SO THAT ARE THE REASON I WOULD SAY GPU ACCELERATION IS IMPORTANT FOR UIS
THERE ARE VAST VAST REGIONS OF THE POSSIBILITY SPACE THAT WILL NOT BE SELECTED AT ALL
THERE ARE WAYS OF SAYING I ACTUALLY KNOW WHAT I WANT TO DO HERE I WANT TO DO THIS SPECIFICALLY
THERE HAS BEEN SOME WORK IN THAT LLVM REALM TO PROPOSE A SIMILAR RFC TO THIS ONE THAT WHAT WE'VE WORKED TOGETHER ON AT HACKS 2020
THERE HAVE BEEN SOME PRETTY INTERESTING IDEAS THAT PEOPLE
THERE I GOT A LOT OF TRAIT BUT I COULDN'T REALLY AT THE BEGINNING UNDERSTAND IT
THERE IS A BIG VARIETY OF MANUFACTURERS AND THEN OF APIS AND PLATFORMS WHICH GIVE YOU SOME SUBSET OF THE APIS BUT NOT ALL OF THEM
THERE IS A FLAGGING
THERE IS A GOOD REASON THAT THE GPU RECEIVES DATA IN SIZE STRUCTS AND SPACED IN CONTIGIOUS ARRAYS
THERE IS A LOT GOING ON HERE SO WE WILL HIGHLIGHT A FEW KEY DETAILS
THERE IS A LOT TO LEARN IN THAT FIELD
THERE IS A TOOL THAT YOU CAN USE TO DETECT UNDEFINED BEHAVIOUR IN YOUR PROGRAMS
THERE IS A WARMING COMMUNITY I HAVE TO SAY ALSO
THERE IS ALSO A QUESTION FROM THE AUDIENCE HOW DO YOU DEAL WITH NON BITE ALIGNED STRUCTURES SO IF LIKE A FIVE BIT WORD CROSSES THE EIGHT BIT ALIGNMENT
THERE IS ALSO AN ENABLE PIN TO CONTROL THE SPEED BUT THIS WILL BE FOR RUST Y 2 0
THERE IS ALSO C INVOLVED THERE AS WELL
THERE IS ALWAYS A SIZE LIMIT
THERE IS AN EXPRESSION DON'T OVERPAD THE PAINTING MEANING DON'T OVERWORK IT AND KILL THE PLAYFULNESS
THERE IS ANOTHER PROBLEM THAT WE HAVE DISCUSSED BRIEFLY
THERE IS ANOTHER THING HERE WHICH IS TO COMPARE WITH PROLOG
THERE IS ARDUINO AND ARDUINO AS WE CAN SAY WHEN YOU ORDER YOUR KIT IT WILL COME WITH A BOARD
THERE IS ENCODING THE DATA AS BYTES ENCODING THAT AS A STRING AND FINALLY RE ENCODING THE ESCAPED STRING
THERE IS HEAD SCRATCHING AND MORE HEAD BANGING ON THE WALL WHICH IS FUN EXHAUSTING AND SOMETIMES OUTRIGHT TERRIFYING BUT NEVER BORING
THERE IS JUST THE RFC WHICH HAS BEEN A LITTLE BIT STALE BECAUSE YOU KNOW LIFE GETS BUSY
THERE IS NO IMPASS USING ANOTHER DEPENDENCY AND FORMAT
THERE IS NO SUPPORT FOR DIRECTLY SUPPORTING BYTES IN GRAPHQL SO MAY MUST BE ENCODED WITH BASE 64 OR SOMETHING SIMILAR
THERE IS NOT GOING TO BE A QUIZ AND THIS IS NOT A TALK ABOUT TYPESCRIPT
THERE IS ONE MORE THING THAT WE CAN DO THIS YEAR AND THIS IS HIGHLIGHTING THE CODE EXECUTION FLOW
THERE IS SOMETHING SUPER IMPORTANT AND THIS IS NOT LIKE AN OBLIGATION YOU HAVE WITH THE COMMUNITY
THERE IS SOMETHING SUPER IMPORTANT IN THAT UNDEFINED BEHAVIOUR IS DIFFERENT IN EACH LANGUAGE
THERE IS THE OCCASIONAL FLAME WAR ABOUT WHETHER IT IS BET TOUR HAVE A HUMAN READABLE FORMAT LIKE JSON OR A HIGH PERFORMANCE FORMAT WITH A SCHEMA LIKE PROTOBUFF BUT THE TRADEOFF SPACE GOES MUCH DEEPER
THERE IS THE POSSIBILITY OF USING WEBASSEMBLY AND HAVING STUDENTS RUN THEIR RUST CODE IN THE BROWSER
THERE IS THIS BUMP AT THE BEGINNING WHERE YOU HAVE TO LEARN THE CONCEPT
THERE ISN'T A WORKING GROUP
THERE REALLY ARE AMPLE
THERE WAS THIS LITTLE BACKEND FOR THIS TIME I HAD
THERE WERE FEW SURPRISES
THERE WERE LOTS OF QUESTIONS AND WE JUST DIDN'T HAVE ENOUGH TIME BUT THANK YOU SO MUCH FOR JOINING US
THERE'S
THERE'S A BOUNDARY THAT'S NOT SATISFIED
THERE'S A BUNCH OF STUFF THAT HASN'T BEEN IMPLEMENTED YET
THERE'S A LOT OF POTENTIAL THERE
THERE'S A REASON FOR THIS
THERE'S A SET OF STEPS WE HAVE TO FOLLOW
THERE'S A STANDARD CALLED JTAG THAT I'M AWARE EXISTS
THERE'S A STANDARD WAY OF DOING IT AND IT'S IN THE RUST COOKBOOK AS WELL
THERE'S A TRACKING ISSUE IN RUST THAT HAS NO
THERE'S ACTUALLY MULTIPLE PHASES TO WHICH THE RUST COMPILER IS RUNNING YOUR CODE
THERE'S ALL SORTS OF THESE HERE
THERE'S ALSO THE ISSUE OF RECURSIVE DATA DEFINITIONS WHICH YOU CAN SEE IN THE CONSLIST CLASS
THERE'S ALSO THE PROBLEM OF CARGO
THERE'S ALWAYS THIS IDEA OF COMPUTER SCIENCE AND MANAGEMENT AND EVERYWHERE OF IMPROVEMENT LOOPS
THERE'S AN EXAMPLE OF THE LIBRARY THAT DOES THAT CALLED NANOVG
THERE'S AN OLD SAYING THAT SHORTCUTS MAKE FOR LONG DELAYS
THERE'S IN NICE KIND OF STANDARD FORMAT
THERE'S NO POINT IN PROTOTYPING THEM EVEN THERE
THERE'S SOME PROGRESS BEING MADE ON SCRYER PROLOG WHICH HAS COOL FEATURES THAT YOU SHOULD LOOK AT IF YOU'RE INTERESTED IN A RUST PROLOG PROJECT
THERE'S THIS VERY DELIBERATE THING WHERE YOU KNOW A LOT OF
THEREFORE I BROKE IT DOWN INTO MULTIPLE STAGES AND EACH STAGE ONLY SOLVES A PARTICULAR LEVEL OF DETAILS STARTING WITH VERY BIG BRUSHSTROKES FORCING TO GENERALISE THE SHAPE AND THEN APPLYING MORE DETAILS
THEREFORE ONE OF THE NEW ADDITIONS TO THE RUST VERSION WAS USING CONTOURS TO GUIDE THE SEARCH
THESE ARE ALL TURNED ON RIGHT AWAY
THESE ARE ENTITIES
THESE ARE INITIALLY PRESENTED AS DRAFTS TO WORKING GROUPS AND THEN BECOME OFFICIAL STANDARDS AFTER FURTHER REVIEW
THESE ARE MINIMALLY DIFFERENT FROM THE FORMAT USING EXISTING DIAGRAMS WITH AUTHORS USING CONSISTENT LABEL NAMES AND CERTAIN SPECIFIC STOCK PHRASES IN THEIR DESCRIPTIONS
THESE ARE PIECES OF DATA IN THE FORM OF THEIR OWN GENERIC COMPONENTS
THESE ARE REQUIRED TO FORM CONGRESSES BETWEEN DIFFERENT DATA UNIT IN THIS CASE ENCRYPTION AND DECRYPTION OF PACKET HEADERS
THESE ARE THE CALLEE SAVED REGISTERS
THESE ARE TINY COMPUTERS
THESE ATTACKS ARE A THREAT IN THE POST SPECTRE WORLD PRIMARILY USED TO ATTACK SECRETS THAT ARE LONG LIVED AND EXTREMELY VALUABLE IF COMPROMISED
THESE BINARIES ARE INSTALLED TO HOME CARGO
THESE CAPABILITIES ARE A SURPRISING NUMBER OF LANGUAGES DON'T MEET THE REQUIREMENTS
THESE COMPONENTS DEFINE PIECES OF DATA THAT HELP DESCRIBE BEHAVIORS THAT WE EXPECT AN ENTITY TO HAVE
THESE CREATE AMBIGUITY FOR PEOPLE IMPLEMENTING PROTOCOLS
THESE IMPACTS ARE NOT RESTRICTED TO THE CASES WE HAVE STUDIED BUT EFFECT EVERY SOFTWARE ENGINEERING PROBLEM
THESE INCLUDE THINGS LIKE YOU KNOW PATCH APPLICATION AND SQUASH OPERATIONS THINGS OF THAT NATURE
THESE LANGUAGES ARE DOING SOME INTERESTING THINGS AS WELL
THESE LINES CORRESPOND TO THE VALUES 0 NEGATIVE 1 AND 1
THESE LOGS REPEAT OVER AND OVER AGAIN TAKING UP THE SAME AMOUNT OF SPACE EACH TIME
THESE MACHINE READABLE DOCUMENTS ALLOW US TO BUILD A TYPED MODEL OF PROTOCOL DATA
THESE OFFSETS ARE DIFFERENT EVEN THOUGH THEY POINT TO THE SAME PLACE
THESE SHOULDN'T BE TOO HARD TO REPLICATE IN RUST SO I'M GONNA LEAVE THAT ALONE
THESE SPANS CAN HAVE A FUNCTION SPAN HAS MULTIPLE SUB SPANS
THESE THREE AREAS ARE CREATED PRIMARILY WHEN WE ORGANIZE THAT INFORMATION AND
THESE TWO ERRORS AGAIN THEY'RE HAPPENING IN THE BORROW CHECKING PHASE WHICH AT THE END OF THE DAY IS KIND OF GOVERNED BY THIS BORROWED CHECKER CONTEXT STRUCT WHICH IS AGAIN PRETTY BIG
THEY ARE A WAY TO DELIVER COMPLEX TOPICS IN A WAY THAT ARE SIMPLE AND EASY TO FOLLOW
THEY ARE ALLOWED TO OPTIMISE THINKING THEY FEEL DOES NOT CHANGE THE PROGRAM
THEY ARE AN OLDER SERIES
THEY ARE CALLED RAW POINTERS
THEY ARE EASY TO DO
THEY ARE MAP UNION JOIN SORT
THEY ARE NOT LIKELY TO BE CRITICIZE BY PEERS FOR USING GZIP WHEREAS THE DELTA COMPRESSION METHOD REQUIRES A FAIR BIT OF CUSTOM CODE
THEY ARE PLATFORM INDEPENDENT
THEY ARE SPRITE RENDERS FOR THE ENEMY SPACESHIP DRONE SHIP AND ENEMY PROJECTILE
THEY ARE TAUGHT THAT IN ADVANCED COURSES BUT NOT AS A FIRST PROGRAMMING LANGUAGE
THEY BASICALLY COMPRISE A VECTOR FORMAT AND A PRETTY MASSIVE AMOUNT OF UIS USE HTML CSS AND THE BROWSER RENDERING ENGINE TODAY
THEY BOTH USE THE SAME API ESSENTIALLY
THEY CAN BE DANGLING
THEY CREATED GAMES WITH THE RUST LANGUAGE
THEY DO NOT HAVE LIKE 100% SUCCESS RATE FOR ALL OUR CASES
THEY DO OTHER THINGS TOO
THEY DON'T APPEAR RANDOM
THEY DON'T CHANGE THE WAY THE SHEEP IS BUT THEY CHANGE THE WE THINK ABOUT IT
THEY DON'T HAVE THIS LIVENESS CONSTRAINTS
THEY FUNCTION AS COMMUNICATION LINES BETWEEN SYSTEMS
THEY GENERALLY HAVE TO DO WITH LOW LEVEL MANIPULATION
THEY GIVE STUDENTS A GREAT WAY TO HAVE FEEDBACK ABOUT THEIR CODE AND KNOW EXACTLY WHAT'S GOING WRONG WITH IT
THEY HAD A PHYSICAL PRODUCT THEY MADE AND WANTED THE SAME COLOR AS THAT
THEY HAVE A DISTINCT BEHAVIOR FOR UNIQUE CHALLENGES
THEY HAVE A SUBSCRIPTION SERVICE
THEY HAVE ASCII ART IN THERE AS WELL AND COLOR CODE THE ERROR MESSAGES TO MAKE IT AS STRAIGHTFORWARD AND UNINTIMIDATING AS POSSIBLE
THEY HAVE MANY GOOD GRADES FOR ERROR HANDLING FOR BETTER ERROR TYPES BETTER CONCURRENCY ABSTRACTIONS ET CETERA
THEY JUST IMPORT OUR LIBRARY USE THIS BYTE ARRAY TYPE ALL OUR FUNCTION THAT I DIDN'T SHOW BECAUSE IT'S NOT IMPORTANT FOR THE PURPOSES OF THIS TALK THAT IS CALLED AND JUST CREATES AN ARRAY FULL OF ZEROES
THEY JUST OPERATOR FUSED COMPUTING DATA UNIT
THEY LEAVE A LOT TO BE DESIRED RIGHT
THEY MIGHT JUST DO SOMETHING LIKE THIS
THEY NEED TO MIRROR EACH OTHER
THEY SCALE UP TO REALLY USING THE GPU
THEY SEE ME ROLLIN'
THEY SHARE THE SAME COMMON CARGO TOML
THEY TAKE ONE BYTE EXACTLY SO YOU HAVE A ONE OR A ZERO BUT A BYTE HAS LIKE EIGHT BITS SO YOU HAVE A LOT OF VALUES THAT YOU COULD USE
THEY TEND TO BE PRETTY SOLID
THEY WANT THAT VARIANT OF THE LIBRARY AND THEY WANT THE VARIANT WHERE THERE IS NO DEPENDENCY ON LAZY STACK GE THIS IS AWESOME BECAUSE IT ALLOWS YOU TO HAVE MULTIPLE VARIANTS OF THE PACKAGE TO SUPPORT MULTIPLE USE CASES AND SYSTEMS
THEY WANT THEIR PROGRAMS TO RUN SUPER FAST
THEY WANT TO MAKE SURE THAT THE STUDENTS HAVE THE FUNDAMENTAL IDEAS OF COMPUTER SCIENCE FIRST
THEY WERE CRITICAL TO THE PROGRESS SO FAR
THEY WILL GET UP TO SPEED VERY VERY QUICKLY
THEY WILL JUST USE GET UNCHECKED AND IF WE RUN THIS IT RETURNS ZERO
THEY'RE BEST EFFORT TRICKS
THEY'RE CHEAP AND VERY HACKER FRIENDLY
THEY'RE EAGER TO PROVIDE HELPFUL CONTEXT PROVIDE HELPFUL ERRORS TO MAKE YOUR JOB YOUR WORKFLOW AS A DEVELOPER EASIER
THEY'RE I WOULD SAY TAKING A SLIGHTLY DIFFERENT APPROACH
THEY'RE JUST NOT IN THE LIMELIGHT AS MUCH I SUPPOSE
THEY'RE NOT GIVEN AS MUCH CREDIT AS
THEY'RE NOTHING MYSTICAL
THEY'RE PURCHASED FROM THE STORE AND MODIFY THE RULES
THEY'RE RELATIVELY AFFORDABLE AND THERE ARE TONS OF ROBOT MAKING WITH ARDUINO
THEY'RE RELATIVELY COMPLICATED DATA STRUCTURES AND THEY'RE COMPACT BUT NOT SO TRANSPARENT TO THE DEVELOPER SO YOU REALLY NEED TO BE ABLE TO DO EFFECTIVE BIT TWIDDLING WHICH OF COURSE IS RUST COMES IN
THINGS THAT ARE SHARED AMONG COMPILERS NO MATTER WHAT LANGUAGE THEY'RE FOR
THINGS THAT ART MAY CREATE
THINGS THAT START SLOW CONCERN QUITE QUICK
THINGS THAT THEY CAN TAKE ADVANTAGE OF FOR THE REST OF THEIR CAREER
THINGS WILL GET EASIER
THINKING COOL TO RIDE RUST Y
THIS A TREE OF BUFFERS HENCE THE NAME
THIS ACTUALLY HAPPENS DURING THE PHASE WHERE RUSTC IS KIND OF VALIDATING THE BORROW CHECKER RULES
THIS ALLOWS STUDENTS TO REDUCE THE AMOUNT OF REDUNDANT CODE THEY HAVE AND TO HAVE THIS COMMON DATA
THIS ALLOWS US TO GET LARGE GRAPHS IN MEMORY SIMULTANEOUSLY BUT THIS REQUIRES A LOT OF BIT TWIDDLING
THIS ALSO HAS
THIS ANIMAL SHARED OBJECT CONTAINS NAME AND WEIGHT AS PUBLIC DATA FIELDS SINCE DOG AND CAT WILL BE THE ONLY ONES THAT WILL BE ABLE TO ACCESS THEM ANYWAYS
THIS APPROACH CAN BE EXPANDED WAY BEYOND TOKIO OR ANY OTHER SINGLE LIBRARY BECAUSE WE CAN USE IT TO ENHANCE DOCUMENTATION THAT IS PRODUCED BY RUST DOC AUTOMATICALLY
THIS APPROACHES REQUIRES A MINIMAL SET UP SO I CAN START EXPLORING THE TOKIO API STRAIGHTAWAY AND I BELIEVE THIS IS SOMETHING WE SHOULD DO TO MAKE RUST MORE ACCESSIBLE TO MORE PEOPLE
THIS BENCHMARK WILL USE REAL WORLD PRODUCTION DATA SERVED BY THE GRAPH A DECENTRALIZED INDEXING AND QUERY PROTOCOL FOR BLOCKCHAIN DATA
THIS BRINGS LOCALITY TO DATA THAT IS SEMANTICALLY RELATED AND OF THE SAME TYPE
THIS CAN BE A LITTLE BIT NOISY SOMETIMES
THIS CAN BE EXTENDED FOR ITEMS THAT AFFECT ANY SYSTEM IN THE GAME
THIS CAN BE USED IN INTERACTIVE PLAYGROUND IN WHICH YOU CAN EXECUTE IN YOUR WEB BROWSER
THIS CAN MAKE IT EASIER FOR WHEN DOCUMENTATION IS CREATED TO ADDRESS THIS SECTION OF THE CODE
THIS CAN ONLY BE DONE AT A COMPILER LEVEL
THIS CAN ONLY HAPPEN IF YOU CAN BE HUMBLE AND DO SMALL LITTLE STEPS WHICH ULTIMATELY ALLOW YOU TO ASCEND FASTER
THIS CAUSED SOME SCENARIOS WHERE IT WASN'T CLEAR WHAT THE SYSTEM WAS SUPPOSED TO DO
THIS COMES DOWN TO THE LIMITS OF EACH COMPONENT IN THE SYSTEM TO PRODUCE AND CONSUME DATA AND THE LIMITS OF THE WIRES CONNECTING THESE COMPONENTS
THIS COULD BE A STORY OR EVEN A SECRET ENDING
THIS COULD GIVE TWICE THE INFORMATION BUT THE AI WOULD BE EXPENSIVE REQUIRE A LOT OF ENGINEERING EFFORT AND ONCE COMPLETED WOULD ONLY BE ABLE TO GUESS THE GAME OF GO WHEREAS THE DELTA COMPRESSION METHOD SOUNDS LIKE IT MIGHT BE USEFUL FOR MORE THAN JUST GO
THIS COULD RANGE FROM CHANGING THE SPEED OF THE PLAYER TO CHANGING THE DAMAGE THE PLAYER DOES TO ENEMIES OR EVEN CHANGING THE PRICES OF ITEMS IN THE STORE
THIS DATA NEEDS TO FIND ITS WAY TO A SYSTEM CALLED SPACESHIP SYSTEM WHICH IS A SYSTEM FOR MANAGING THE SPACESHIP ATTRIBUTES
THIS DEFINES SECRET PRIMITIVE TYPES AND THE INSTRUCTIONS THAT SHOULD BE DEFINED FOR EACH TYPE
THIS DROVE ME TO TAKE A LOOK AT RUST
THIS EFFECTIVELY SERVES AS A LINKED LIST
THIS EVENT CHANNEL CAN BE THOUGHT OF AS A RADIO TOWER BROADCASTING A MESSAGE
THIS EXAMPLE DEMONSTRATES ONLY THE ABSTRACT IDEA OF SENDING AN HTTP REQUEST BUT HOW DO WE KNOW HOW IT ACTUALLY WORKS
THIS FUNCTION WILL ALSO SPECIFICALLY CHECK FOR A EXTRA LEADING ANGLE BRACKET
THIS GENERALIZES WELL TO OTHER DATASETS
THIS GIVES THE USER AN IMMEDIATE CONTEXT AND RESPONSE OF WHAT HAPPENS WITH THEIR CODE AND THE STATE OF THE MINI REDIS SERVER CAN BE OBSERVED RIGHT THERE IN THE BROWSER
THIS GOES BACK TO THE EMBEDDED HAL
THIS HAD MUCH BETTER PERFORMANCE THAN I EXPECTED FROM HOW KIND OF WEIRD OF A DESIGN AND ALSO HOW SIMPLE IT IS
THIS HAPPENS BECAUSE MIRI HAS TO DO A LOT OF RUNTIME CHECKS ABOUT YOUR POINTERS AND HOW MEMORY IS MANAGED TO BE ABLE TO TELL YOU WHEN UNDEFINED BEHAVIOUR IS HAPPENING
THIS HAPPENS WHEN STD IS NOT ENABLED
THIS HELPED ME IN LEARNING RUST
THIS INDICATES OUR DATA IS LESS RANDOM
THIS INTRODUCES A LOT OF GOOD HABITS TO STUDENTS AND ENSURES THAT THEY WALK AWAY WITH A LOT OF GREAT SKILLS AND UNDERSTANDING OF HOW TO PROPERLY HANDLE THE SAMENESS OF DATA
THIS IS 10 496 BOXES
THIS IS A 16 LONG SIXTEEN BIT LONG BIT STRING THAT WAS THE PARSER THAT WE WALKED THROUGH EARLIER
THIS IS A COMMUNITY IN WHICH I FELT SAFE AND COMFORTABLE FROM DAY ONE
THIS IS A DRASTIC INCREASE IN AND DOESN'T INCLUDE THE LATEST IPHONE IT'S LIKE 2700X1100 PIXELS
THIS IS A HUGE OVERSIMPLIFICATION
THIS IS A LITTLE BIT MORE DIFFICULT TO GENERATE
THIS IS A PROBLEM
THIS IS A PROCESS KNOWN AS WELDER WHERE METAL PARTS ARE MELTED TO FORM ONE SOLID BLOCK
THIS IS A REALLY NICE WAY YOU CAN DO A
THIS IS A RUST ERROR MESSAGE THAT IS A LITTLE BIT OBTUSE ALSO LEAVES SOMETHING TO BE DESIRED
THIS IS A TALK CALLED�CANNING RUST FOR SCIENTIFIC SOFTWARE
THIS IS A TECHNICAL CONFERENCE
THIS IS A VERTEXT BUFFER
THIS IS A VERY COMMON BEGINNER MISTAKE
THIS IS A VISUALIZATION OF IPHONE SIZES OVER TIME
THIS IS AGAIN SOMETHING THAT I DIDN'T WANT TO TEACH STUDENTS
THIS IS ALL OF THOSE LITTLE 8X8 CHUNKS PUT IN ORDER IN THE ATLAS
THIS IS ALREADY MEMORY BOUND
THIS IS ALSO A BIT STRING AND THEREFORE A LEAF NODE SO WE WRITE A CUSTOM TYPE AND A SIXTEEN BIT PARSER FOR THIS
THIS IS AN EXAMPLE TEXTURE ATLAS THIS IS WHAT IT LOOKS LIKE FOR THE TIGER
THIS IS AN INTERESTING QUESTION
THIS IS C PLUS PLUS CODE BUT MOSTLY CONCERNED ABOUT THE COMMENTS
THIS IS COMPILED AND ON THE RIGHT SIDE I CAN SEE A KEY HELLO HAS BEEN SET TO VALUE WORLD
THIS IS DESCRIBED IN THE DOCUMENTATION
THIS IS DONE BY COMPARING EDGES OF TARGET VERSUS DRAWN AND COMPUTING THEIR DISTANCE
THIS IS DONE BY CREATING A PACKAGE IN THE BINARY OR LIBRARY CRATE
THIS IS DONE BY USING THE CFG TABLE
THIS IS DONE WHENEVER YOU RUN CARGO AND A BINARY NAMES
THIS IS EXACTLY HOW IT WORKS
THIS IS EXPERIMENTAL
THIS IS FEATURES THAT ARE NOT RELEVANT TO THE CURRENT GOAL SUCH AS FUTURE PROJECT IDEAS AND IMPLEMENTATION IDEAS THAT ARE OFF TOPIC
THIS IS GARBAGE
THIS IS GOING TO BE AN ERROR IN LATER VERSIONS OF THE COMPILER
THIS IS GOING TO SEND THE SOUND WAVE
THIS IS HOW AMETHYST UPDATES COLLECTIONS OF THEM
THIS IS HOW IT MIGHT LOOK
THIS IS IDEAL FOR PROTOCOL TESTING
THIS IS IMPORTANT BECAUSE WE HAVE TO NOT BE AFRAID OF SHARING IDEAS TO MAKE SURE THAT WE ARE ON THE SAME PAGE WITH THE PROJECT
THIS IS IMPORTANT FOR ME BECAUSE I WANT THE USERS OF MY LIBRARY TO NOT HAVE TO TAKE DEPENDENCIES BECAUSE I AM TAKING A DEPENDENCY
THIS IS IMPORTANT WHEN A SYSTEM NEEDS TO OPERATE ON HUNDREDS OF COMPONENTS AT A TIME
THIS IS JUST ONE EXAMPLE OF A TYPE OF ERROR THAT'S SURFACED DURING PARSING AND THE THING WITH WHEN YOU'RE ACTUALLY GOING AHEAD AND PARSING THERE'S THIS ONE DATA STRUCTURE THAT IS RESPONSIBLE FOR THE ENTIRE PARSING PHASE WHICH IS CALLED THE PARSE SESSION HERE
THIS IS JUST THE NUMBER OF HARDWARE INQUIRIES IN THE CURRENT SOCKET
THIS IS KNOWN AS CONTINUATION AND IT MEANS THAT WE CAN CONTINUE THE EXECUTION OF A FUNCTION FROM THE POINT THAT WE LEFT IT AT
THIS IS LIKE THE LISTS THAT A PROGRAM FOLLOWS WHEN IT IS GETTING COMPILED
THIS IS MADE EASIER BY HAVING THE CARGO INSTALL WHICH CAN BE USED TO INSTALL BINARIES
THIS IS NOT SO MUCH
THIS IS NOTHING TO WORRY ABOUT
THIS IS PROBABLY WHAT YOU SHOULD USE AND WE DON'T HAVE ANYTHING BETTER AT THE MOMENT AND THE OTHER EXAMPLE THAT I WOULD LIKE TO MENTION IS THE SECRET INTEGERS CRATE WHICH IS A BIT MORE ACADEMIC OF NATURE
THIS IS RELATED TO THE TIME RESOURCE RESULTING IN THE ANIMATION SEQUENCE
THIS IS SIMILAR TO WHAT PATHFINDER DOES IT DOES MORE ON THE CPU WHEREAS PATHFINDER DOES MORE ON THE GPU
THIS IS SIMPLY TO KEEP A LITTLE BIT OF CONSISTENCY EVEN THOUGH DOUBLE'S EXACT TRANSLATION WOULD BE AN F SIXTY FOUR
THIS IS SOMETHING THAT RUST DOESN'T ALLOW AND SO WE MUST FIND A WAY AROUND IT
THIS IS SOMETHING THAT WE MUST WORK AROUND IN RUST
THIS IS SOMETHING YOU CAN DO WITH THIS STUFF
THIS IS SUPER COOL BECAUSE MAYBE YOU CAN USE MIRI IN ONE SITUATION WHEN YOU'RE NOT SURE THESE CODES THAT YOU WROTE SPECIFICALLY FOR WINDOWS IS WORKING CORRECTLY
THIS IS SUPER SUBJECTIVE
THIS IS THE AREA THAT I WOULD LIKE TO TALK ABOUT TODAY
THIS IS THE CODE FOR THE SENSOR
THIS IS THE CURRENT STATE OF THE ART THAT WE HAVE
THIS IS THE FINAL HTML SITE THAT CARGO DOCS GENERATES WITH ALL OF THE TYPE DATA AND THE COMMENTS ARE NOW CONVERTED INTO DOCUMENTATION WHICH IS PRETTY AWESOME TO LOOK AT AND PRETTY USEFUL
THIS IS THE GENERAL TIMER THAT HAS BEEN PRESCALED BY A FACTOR OF 64 THAT WE ARE GOING TO USE MOSTLY WITH THE SENSOR BUT ALSO AS A GENERAL TIME CHECKER FOR THE WHOLE PROJECT AND THEN THE TIMER2 AND IT IS PIN D3 THAT WE ARE GOING TO USE FOR THE CELL
THIS IS THE KIND OF PLEASANTRY I HAVE COME TO EXPECT FROM RUST DEPENDENCIES
THIS IS THE NEXT PART OF THE INSTRUCTOR'S PLAN AND IT'S A GREAT WAY TO INTRODUCE STUDENTS TO THE RESULTS TYPE OF RUST
THIS IS THE OPEN64 FUNCTION I WAS TALKING ABOUT
THIS IS THE UNEXPECTED BONUS ROUND
THIS IS USED AS A HOMEWORK TO COPY AND LEARN FROM ON HOW TO DECONSTRUCT A THREE D SHAPE INTO SIMPLIFIED CONTOURS
THIS IS USEFUL BECAUSE THE PROJECT WILL BE IN THE SAME FORMAT FOR THE DEVELOPERS TO EASILY READ AND UNDERSTAND THEM WITHOUT HAVING TO FIGURE OUT STUFF
THIS IS USEFUL FOR EMBEDDED SYSTEMS
THIS IS VERY USEFUL IF YOU ARE TRYING TO FIND HARD BUGS IN RUNTIME
THIS IS WHAT AN EXAMPLE MIGHT LOOK LIKE
THIS IS WHAT I WANTED TO SHOW IN MY TALK HOW DO I GET STARTED
THIS IS WHAT THE HORIZONTAL LINES LOOK LIKE THAT GET UPLOADED TO THE GPU
THIS IS WHAT WE ARE GOING TO DO
THIS IS WHAT YOU NEED FOR YOUR CARGO FILE SO WE CAN GO BACK TO THE CODE
THIS IS WHEN I INVITED MICAH TO COLLABORATE ON SPACE SHOOTER RS
THIS IS WHERE THE BORROW CHECKING HAPPENS
THIS IS WHERE THE PROGRAM STORES THINGS THAT IT MAY NEED LATER BUT IT DOESN'T NEED RIGHT NOW
THIS IS WRITTEN IN RUST
THIS LEADS TO THE THIRD DIFFERENCE WHICH IS LIMITATIONS ON DEBUGS AND OBSERVABILITY
THIS LIBRARY WAS EXHIBITING NONE OF THESE PROBLEMS AND THIS WAS REALLY PROMISING
THIS MAKES DEVELOPMENT MUCH MORE DATA DRIVEN SINCE ENTITIES ARE DEFINED BY THE COMPONENTS THAT ARE ATTACHED TO THEM
THIS MAKES EACH ENUM VARIANT A STRUCT TYPE IN OUR NETWORK PACKET REPRESENTATION SYSTEM IN THIS CASE EOL OPTION IS A STRUCT
THIS MAP ERROR NEVER ACTUALLY GETS CALLED
THIS MAYBE THEN COULD BE A STEP FORWARD FOR YOUR COMPLEX PROJECT
THIS MEANS THAT MIRI DOESN'T COMPILE YOUR PROGRAM IT INTERPRETS IT IN THE SAME SENSE THAT THE JVM INTERPRETS JAVA CODE OR BYTE CODE OR THAT THE PYTHON INTERPRETER RUNS PYTHON OR THE RUBY INTERPRETER RUNS RUBY
THIS MEANS WE ARE FINALLY REACHED THE LEAF NODE AND WE CAN WRITE A CUSTOM RUST TYPE DEFINITION AND A NOM PARSER AND A RUST TYPE DEFINITION AND A PARSER FOR ITS PARENT NODE EOL OPTION
THIS MEANS YOU CAN USE SOME KIND OF LOSSY COMPRESSION BUT NOT LOSS LESS COMPRESSION
THIS MEANT MODIFYING THE HEALTH STAT OF AN ENTITY WOULD NEED TO SPECIFICALLY ACCESS THE COMPONENT CONTAINING IT RATHER THAN A GENERIC HEALTH COMPONENT
THIS MODEL IS THEN EXECUTED IN YOUR BROWSER AND YOU CAN SEE THE OUTPUT
THIS MOTION COMPONENT APPLIES TO ENTITY MOTION WITHIN A 2 DIMENSIONAL SPACE
THIS MOVIE DEPICTS A GAME OF GO
THIS NEEDS OTHER TO BE CLONED OR IT'S SOMEWHERE ELSE
THIS NOTION OF IMPROVING THE CULTURE AROUND ERROR MESSAGES AND ARE DOING SOME COOL THINGS THERE AS WELL
THIS OBSERVATION GENERALIZES TO MANY OTHER KINDS OF DATA AS WELL
THIS OF COURSE IS ONE OF THE THINGS THAT RUST DECIDED NOT TO DO AND WAS ONE OF THE DECISIONS THAT CREATED A LOT OF DIFFERENCE BETWEEN RUST AND A LOT OF OTHER LOW LEVEL LANGUAGES
THIS OF COURSE IS VERY FLEXIBLE AND COULD ACTUALLY BE SOMETHING THAT COULD BE USED IN A COURSE LIKE THIS
THIS ONE
THIS ONE DOES NOT NEED AS MUCH PRESCALING AS TIMER 2 THAT WE USE FOR THE SERVO SO WE WILL JUST MAKE IT 64 TIMES SLOWER
THIS ONE IS A COMPILER
THIS ONE IS SUPER IMPORTANT
THIS OPT IN LOW LEVEL CONTROL IS WHAT SETS RUST APART FROM A LOT OF OTHER MEMORY SAFE LANGUAGES
THIS PART IS NOT INTERESTING BUT THE CODE HAS TO BE THERE OR THE PROGRAM WILL CRASH WHEN THE BUFFER RUNS OUT OF SPACE
THIS PRESENTATION WILL BE ABOUT MAKING A ROBOT IN RUST AND WORKING WITH NO STD
THIS PROBLEM COMPOUNDS IF YOU WANT TO NEST A BYTE ARRAY CONTAINING ANOTHER SERIALIZATION FORMAT IN GRAPHQL
THIS PROVIDES DISTRIBUTED IMPLEMENTATION OR ASYNCHRONOUS SYSTEMS LIKE TOKYO AND ETC
THIS QUESTION COME FROM THE CHAT
THIS QUESTION OF WHERE DO WE INSERT THE FRAME POINTER RESTORATION
THIS REQUIRES THE EXCHANGE OF MONEY AND THAT REQUIRES WORKFLOWS AND INTEGRATION WITH COUNTING SYSTEMS
THIS SCATTER PLOT IS A VISUAL REPRESENTATION OF THE ACTUAL BYTES OF A GO GAME
THIS SHARPLY INCREASES THE RATE OF FIRE FOR THE PLAY
THIS SHOWS GZIP DELTA AND AI
THIS SHOWS THAT THE ANIMATION SYSTEM NEEDS TO READ FROM A TIME RESOURCE
THIS SIMPLY DOES NOT HAVE
THIS SLIDE SHOWS A SCREENSHOT OF THE GAME WITH FIVE CIRCLED OBJECTS
THIS SPEAKS TO AGAIN THE QUESTION THAT WE HAD COMING INTO THIS TALK WHICH WAS
THIS TALK COVERS FROM MULTIPLE PERSONALITY DISORDER LIKE TALK ABOUT SIMILARITIES BETWEEN ART PROGRAMMING AND SCIENCE AND AT THE SAME TIME SHOWING YOU COMPLICATED DRAWING ALGORITHMS AND ALSO HAS PRACTICAL TIPS
THIS TALK INSPIRED ME TO WORK ON THE GAME AGAIN
THIS TALK IS CALLED MIRI UNDEFINED BEHAVIOUR AND FOREIGN FUNCTIONS
THIS TALK IS FOR PEOPLE WHO ARE INTERESTED IN RUST OR MAYBE LOOKING FOR AN ALTERNATIVE LANGUAGE FOR THEIR PROGRAMMINGS OR RESEARCH
THIS TALK IS IN THREE STAGES
THIS TALK IS TIER 3 MEANS GETTING YOUR HANDS DIRTY
THIS TALK WILL HAVE FOUR PARTS BASICALLY
THIS TELLS YOU WHAT THE PROCESSER HAS BEEN UP TO RECENTLY
THIS THE DATA STRUCTURE IN LATE IR
THIS TIME IN THE FORM OF POINTER CHASES WHEN ACCESSING THE PROPERTIES OF OBJECTS IN TYPESCRIPT
THIS TIME IT IS USING ENVIRONMENT VARIABLES TO SET THE SIZE AND INDEX IT WANTS TO READ
THIS TRANSFORMATION IS ONLY POSSIBLE IF YOU KNOW THE SCHEMA OF THE DATA BEING WRITTEN
THIS TRANSFORMATION TECHNIQUE IS ACTUALLY PRETTY WELL KNOWN AND EVEN THE RUST COMPILER ITSELF USES IT FOR ASYNCHRONOUS CODE
THIS TURNED INTO A MORE INFORMAL IDEAS DOCUMENT WHERE WE THROW IDEAS FOR DISCUSSION AS WE THINK OF THEM
THIS TYPE IS A COW OF STRING
THIS TYPE SEEMS REALLY REALLY LONG BUT YOU KNOW HOW YOU DO WITH RUST WHEN YOU DON'T KNOW A TYPE YOU JUST DECLARE ANOTHER TYPE THE COMPILER WILL COMPLAIN AND GIVE YOU THE RIGHT TYPE AND YOU CAN JUST COPY PASTE IT
THIS UNSAFE BLOCK IS SORT OF THE VISUAL EQUIVALENT OF THAT
THIS WAS A SIMPLE WAY TO KNOW WE NEEDED TO GET THE PHYSICAL COLOR SAMPLE FROM THE CUSTOMER
THIS WAS ONE OF THE MAIN MOTIVATIONS
THIS WILL ENABLE YOU TO HAVE WELL A LOT OF CERTAINTY A LOT OF PRACTICE WHEN YOU FINALLY MOVE ON TO HARDER AND MORE COMPLEX TOPICS
THIS WILL MAKE IT EASIER FOR PEOPLE TO JUST IMMEDIATELY SEE THE OUTPUT WITHOUT SWITCHING THE CONTEXT
THIS WON'T WORK IN RUST
THIS WOULD HELP CONCEPTUALIZE HOW THE ENTITY COMPONENTS WORK TOGETHER
THOSE ARE TO COMMUNICATE WITH THE BATTERY AND THIS IS A FIVE VOLT LOGICAL PIN THAT I'M GOING TO USE IN THE DEMO
THOSE CAPABILITIES ARE INHERENT TO THE REPRESENTATIONS THEMSELVES
THOSE IN THE COMMENTS ARE COMMANDS TO GET YOUR CONSOLE WORKING
THOSE THREE CRATES ARE MODULES THAT I USED TO SEPARATE MY CODE WHEN I WAS REFACTORING BECAUSE I FELT THAT IT WOULD BE MORE CLEAR AND ALSO BECAUSE I WAS TRAINING WITH RUST'S DATA STRUCTURES
THOUGH THIS BATTLE IS SOMEWHAT UPHILL
THREE PARTS OF OUR MEMORY
THREE UA SLOTS AND A BLANK SLOT FOR PADDING MAKING IT ALL LOG UP
TIER 3 MEANS GETTING YOUR HANDS DIRTY
TIER THREE HAS GOT SOME ROOM TO GROW
TIME TO LOOK AT BENCHMARKS
TO AN ERROR TO A REFERENCE TO UNIT I CAN MAKE THE BUG APPEAR AND DISAPPEAR
TO AWE CHIEF CERTAIN PERFORMANCE GOALS
TO BECOME A DEBUGGING DETECTIVE
TO BEST REPRESENT THE DATA IN THAT WAY AND IT WASN'T
TO BREAK THEM DOWN IN A WAY THAT MAKES THEM REUSABLE AND CONCISE IT HELPS TO DEFINE A SET OF REQUIREMENTS
TO CENTRE IT WE DEFINE THE TIME TIMES THE REGISTER
TO CREATE A GREAT UI IN FACT
TO DISCUSS AND PRIORITIZE TASKS TO GET THE CODE IN A BETTER PLACE
TO FEEL GOOD ABOUT OURSELVES BECAUSE WE HAVE GRASPED AND MASTERED THE FEATURES OF OUR LANGUAGE BECAUSE WE WRITE GOOD CODE
TO GET RUST TO THE METAL TO MILL
TO GET THE CARGO FROM THE CONFIGURATION YOU CAN AGAIN GO TO THE DOCUMENTATION HERE AND EVERYTHING IS EXPLAINED IN 0 5
TO GIVE YOU AN EXAMPLE I WOULD LIKE TO SHOW YOU TWO OF THE RECENT PROJECTS WE DID AT EMBARK
TO GIVE YOU AN EXAMPLE OF HOW THIS WOULD WORK HERE'S A MOCK UP ERROR MESSAGE OF WHAT WOULD HAPPEN IF WE BROKE ONE OF THESE RULES
TO GO AHEAD AND LOOK AT SOME OTHER LANGUAGES HERE IS A BLOG POST THAT THE CREATOR OF ELM AGAIN KIND OF THE OTHER PROGRAMMING LANGUAGE THAT I WOULD CONSIDER TO HAVE S TIER ERROR MESSAGES
TO GO FURTHER WITH THAT ANALOGY A TCP HEADER IS A LOT LIKE THIS LEGO BLOCK DINOSAUR HERE
TO GUIDE THE BRUSHSTROKES I GENERATE AN IMAGE GRADIENT FIELD
TO HELP US WE WILL VISUALIZE THE RAW DATA FROM THE DATASET
TO ILLUSTRATE THE POINT WE CAN LIST THE EXPECTED BEHAVIORS OF THE SPACESHIP AND ITEM ENTITIES AS COMPONENTS
TO MAKE CODE EASIER TO REALIZE
TO MAKE HASHTABLES AND B TREES DANCE
TO MAKE IT WORK YOU WILL NEED SOME CONSTANTS
TO ME THIS REALLY SPEAKS ABOUT CULTURE
TO MOVE IN THE SPACE ALL WE HAVE TO DO IS CHANGE OUR CANVAS
TO NEWBIES WHO START OUT AND MUST
TO SEE IF THE SPECIFIED BEHAVIOUR MAKES ANY SENSE RIGHT
TO SEE THINGS ON THE SCREEN YOU WILL NEED THE SERIAL SO WE'VE A RECEIVER A SENDER AND A BAUD RATE SO THIS IS
TO SEE WHAT'S INSIDE
TO SHOW FRESHMEN THE LANGUAGE IS COOL
TO TALK ABOUT HOW MIRI WORKS WE HAVE TO DIG INTO HOW THE RUST COMPILER WORKS
TO THE FARTHEST REACH OF RUST TO SHOW
TO THE GAME AND WHAT KIND OF COMPONENTS AND SYSTEMS IT WOULD REQUIRE
TO THEN SIMULATE
TO TRY TO GET IT TO WORK OR NOT WORK
TO TURN RIGHT YOU NEED TO STOP THE WHEELS THAT IS EXACTLY THE TO STOP THE WHEELS YOU JUST NEED TO SET ALL THE PINS LOW RIGHT
TO WHAT IT WAS PRIOR TO ENTERING OUR INTERRUPT SERVICE ROUTINE
TODAY I WOULD LIKE TO EXPLORE USES OF A MORE DESIRABLE RUST
TODAY I WOULD LIKE TO SHARE SOME OF MY EXPERIENCES USING RUST IN METAL FABRICATION
TODAY I'M PRESENTING A PROJECT I HAVE BEEN WORKING ON CALLED OCHRE WHICH IS A GPU ACCELERATED VECTOR GRAPHICS AND TEXT RENDERER LIBRARY FOR RUST
TODAY THERE ARE PLENTY OF ART MEDIA TO CHOOSE FROM AND CODE IS A PARTICULARLY FASCINATING ONE AS IT INVITES TO CONVEY NOT JUST A FINAL DESTINATION OF THE ART PROCESS BUT THE AUTHOR'S WORKFLOW THE SEARCH ITSELF
TODAY'S TALK WILL BE A PRIMARILY NON TECHNICAL PERSPECTIVE ON USING RUST IN THE DEVELOPMENT OF ENTERPRISE SOFTWARE
TOO MUCH INFORMATION HERE
TRACING ALLOWS YOU TO HAVE CONTEXTUAL INFORMATION
TRACK THE FLOW OF PHYSICAL GOODS AND THE MONEY
TREE BUF GENERALIZES THIS PRINCIPLE AND USES TYPE AWARE COMPRESSION METHODS FOR THE DIFFERENT KINDS OF DATA IN THE TREE
TREE BUF GENERALIZES THIS TO THE ENTIRE SCHEMA
TREE BUF IS ALSO SELF DESCRIBING WHICH MEANS YOU COULD OPEN UP AND READ ANY TREE BUF FILE WITHOUT REQUIRING A SEPARATE SCHEMA TO INTERPRET THE DATA ALSO MAKING IT A GOOD FIT FOR GRAPHQL
TREE BUF IS EASY TO USE
TREE BUF IS MORE THAN 10 TIMES AS FAST AS GEO JSON
TREE BUF IS TAKING ADVANTAGE OF BEING ABLE TO LIKE FIND PREDICTABILITY IN DATA WITH ARRAYS
TWO OF THEM ARE POWER
TWO THINGS
TYPICALLY WHEN THE INSTRUCTORS INTRODUCE GENERIC TYPES THEY INTRODUCE IT BY REIMPLEMENTING THE FUNCTIONAL MONAD LISTS
ULTIMATELY IT HAS A LOT OF ADVANTAGES AND A LOT OF DISADVANTAGES
ULTIMATELY THERE ARE SOME ISSUES WITH GO STILL
ULTIMATELY THIS WAS A GREAT WAY TO THINK ABOUT HOW AN INTRODUCTORY
UNDERSTAND THEY ALLOW PROGRAMMERS TO CONTAIN DIFFERENT KINDS OF DATA IN THEIR TYPES
UNFORTUNATELY THERE ARE STILL SOME DISADVANTAGES TO THIS COURSE
UNFORTUNATELY THERE'S NO WAY AROUND IT
UNIONS ARE LIKE ENUMERATIONS BUT THEY DON'T HAVE THE CONSISTENT BACK TO DISTINGUISH EACH VARIANT
UNSAFE CODE IS NOT OKAY
UNSAFE IS ALSO SOMETHING THAT STUDENTS SHOULD LEARN HOW TO USE IN RUST BUT THEY SHOULD ONLY LEARN HOW TO USE IT PROPERLY
UNSURPRISINGLY THE DESIGN OF THE SERIALIZATION FORMAT WHICH IS THE DESIGN OF HOW THE COMPONENTS INTERACT HAS LARGE EFFECT ON THE SYSTEM AS A WHOLE
UNTIL LATER
UNTIL NEXT TIME
UNTIL STEALING THE SHOW
UNTIL THEIR OWN EXPERIENCE THEY TRUST
UP WITH AN ECS
US SEE WHAT IT WILL TAKE
USE RUST TO GENERATE
USES MODERN GPU COMPUTE FEATURES TO RENDER IT FROM SCRATCH THERE
USING A LANGUAGE SERVER YOU WILL GET THIS IS PRETTY AWESOME
USING AN ALLOCATOR MAKES A LOT OF SENSE
USING GZIP ALSO ENTAILS INTRODUCING A SECOND STEP
USING GZIP ASSUMES YOU ALREADY HAVE SOME METHOD FOR WRITING STRUCTURED DATA LIKE PROTOBUFF OR CSV OR MESSAGE PACK OR WHATEVER
USING MIRI INSIDE THE COMPILER
USING PARSER COMBINATORS TURNED OUT TO BE AN IDEAL FIT SINCE ASSIGNING THEM TO NETWORK PROTOCOLS BOTH USED DEPTH OF SEARCH
USING RUST IN METAL FABRICATION
USING RUST ITSELF HAS BEEN TECHNICALLY AN AMAZING EXPERIENCE AND FROM A NON TECHNICAL PERSPECTIVE DIFFERENT KIND OF EFFORTS WERE REQUIRED FOR HIRING AND TRAINING TO MAINTAIN THIS KIND OF EFFICIENCY IN OUR DEVELOPMENT BUT THE FRIENDLY AND WELCOMING COMMITTEE HAS BEEN ABSOLUTELY WONDERFUL
USING RUSTDOC YOU CAN GENERATE A SITE WITH THE UI OF ALL THE DATA
USING THESE RESOURCES THE ANIMATION SYSTEM WRITES TO AN ENTITY SPRITERENDER COMPONENT
USUALLY WE JUST HAVE TO RERUN OUR CODE TO DO ANOTHER ANALYSIS JOB
USUALLY WHAT HAPPENS IS THE SYSTEM LIKE YOU HAVE THESE TWO FUNCTIONS YOU HAVE LIKE THE UNSAFE UNCHECKED VERSION OF A FUNCTION AND THEN YOU HAVE THE YOU HAVE THE SAFE VERSION OF IT
VALUE IS GENERIC OVER THE KIND OF TEXT TO PARSE INTO
VECTOR GRAPHICS IT'S A REALLY GOOD TOOLKIT FOR PROCEDURAL VISUALIZATIONS LIKE THAT
VERSION 6 HAS BEEN OUT SINCE TUESDAY I THINK
VERTEX POSITION AND COLOR ARE UNSURPRISING
VERY BROAD BUT I THINK IT WOULD BE GREAT TO HEAR YOUR INSIGHT ON THIS
VERY INTERESTING
VERY LITTLE IS GOING ON IN THE CENTER
VERY VERY GOOD POINTERS
VIVIAN WANTS US TO BE SAFE
VULKAN AND THE METAL ARE ONLY AVAILABLE IF YOU HAVE A 10 YEAR OLD DESKTOP IT MAY NOT BE ABLE TO RUN THE FEATURES
WANNA SEE ME RIDING RUST Y
WANT TO SEE ME WANT TO SEE ME RIDING RUST Y
WAS ALSO QUITE QUICK TO LEARN BECAUSE IT WAS NOT TOO MUCH TO LEARN
WAS THIS CULTURE OF TECHNOLOGY
WAS THIS THE PYTHON LIKE THING
WATCHING YOUR TALK I WANT TO DO SOMETHING TOO
WE ACTUALLY FOUND A VERY HIGH QUALITY COVERAGE ACROSS OUR NEEDS
WE ACTUALLY WRITE EVERYTHING TO DISK BUT WE LEAVE THINGS IN MEMORY
WE ALSO CHECKED TO SEE THAT THE AGE IN DOG YEARS OF THE DOG IS VALID AND WE RETURNED THE ERROR IF NOT
WE ALSO CREATE A CONTEXT OBJECT WHICH ALL PARSER FUNCTIONS HAVE ACCESS TO
WE ALSO HAVE A FEW SPECIAL PURPOSE REGISTERS
WE ALSO HAVE DONE SOME BULK OPERATIONS THAT FOR INSTANCE IN CSC LOADING HAS BEEN WRITTEN COMPLETELY IN RUST AS WELL
WE ALSO HAVE THE COUNT METHOD WHICH IS AVAILABLE WHICH ITERATES OVER ALL OF THE ITEMS IN THE LIST AND COUNTS HOW MANY ITEMS THERE ARE
WE ALSO HAVE TO CALCULATE EACH ELEMENT SIZE BOTH IN UNITS OF BYTES AND FLOATS FOR SIMILAR REASONS
WE ALSO HAVE TO FIGURE OUT WHETHER OR NOT WE'RE GONNA REPLACE CARGO SINCE STUDENTS DON'T REALLY NEED TO LEARN HOW TO MANAGE DEPENDENCIES
WE ALSO HAVE TO INTRODUCE STUDENTS TO REFERENCES SINCE RUST IS VERY DEPENDENT ON MANUAL PATH BUSINESS REFERENCE
WE ALSO IF I CHANGE AN INLINE ANNOTATION TO INLINE NEVER THAT MAKES THE BUG DISAPPEAR
WE ALSO LOOKED AT THE SAME SAID OF TRAIT OBJECTS
WE ALSO MUST USE HEAP ALLOCATION
WE ALSO NEED TO BUILD WITH CARGO THE NIGHTLY BUILD TO INDICATE THAT WE ARE GOING TO USE NIGHTLY
WE ALSO NEED TOOLS FOR PARSING AND MANIPULATING NEST DATA
WE ALSO RETURN MUTABLE REFERENCE TO OUR POSSIBLY UPDATED CONTEXT
WE ALSO SIMPLIFIED SOME OF THE PROPERTIES TO BE REPRESENTED AS VECTORS
WE ALSO USE SUCCINCT DATA STRUCTURES WHICH APPROACH THE INFORMATION THEORETIC MINIMUM SIZE WHILST ALLOWING QUERY IN THE DATA STRUCTURE
WE ARE ABLE TO RUN THE RUST CODE IN THE BROWSER BY USING ASSEMBLY AND THE PLATFORM SUPPORT IS CONSTANTLY EXPANDED AND IMPROVED IN THE COMPILER SO WE CAN MAKE IT WORK QUITE EASILY
WE ARE AIMING TO INTRODUCE OUR MACHINE READABLE ASCII FORMAT TO FEATURE IETF DRAFTS AND HOPEFULLY WE WILL SEE MORE ADOPTION OF THAT SO WE CAN SEE AUTOMATED TESTING GOING FORWARD
WE ARE AIMING TO SHOW OUR SYSTEM TO THE IIETF
WE ARE ALL AT HOME AND IN IT TOGETHER
WE ARE BACK TO THIS GRAPH BUT I WANT TO POINT TO THE CORNER IN TENSORBASE IS A SAFE ORGANIZEDED COMPONENT WHICH WILL INTERACT TO THE WHOLE RUST SYSTEM
WE ARE DOING PRETTY WELL IN THAT AREA WITH OTHER SERIALIZATION FORMATS
WE ARE EVALUATING A MORE DIRECT APPROACH CURRENTLY
WE ARE EXPLORING FOUR APPROACHES WHICH ARE COLLABORATIVE CODING PRACTICES WRITING DOCUMENTATION TOGETHER COMMUNICATION AND WEEKLY MEETINGS
WE ARE GETTING BETTER
WE ARE GOING A LITTLE QUICK
WE ARE GOING TO REDUCE THE FREQUENCY BY DIVIDING IT BY 1 024 AND WE CAN THEN WORK WITH A CYCLE OF 16 MILLISECONDS
WE ARE GOING TO TURN THE SERVO TO THE RIGHT GET THE VALUE HERE WAIT BETWEEN TO INTERACTION AND THEN DO THE SAME FOR THE LEFT AND THE REST IS JUST IF THE VALUE IS BIGGER ON THE LEFT THAN THE RIGHT AND IT'S AN ACCEPTABLE DISTANCE LIKE THERE IS NOT ANOTHER OBSTACLE HERE THEN WE'RE GOING TO TURN THE WHEELS LEFT AND THEN CONTINUE TO THE OUTER THAT IS GO FORWARD
WE ARE GOING TO WRITE A VARIABLE LENGTH ENCODING
WE ARE HOWEVER ALSO ACID SO WE USE BACKING STORE
WE ARE INSTALLING THIS INTO OUR LOCAL PACKAGE
WE ARE INSTILLING OUR EXAMPLE WITH A BYTEARRAY CRATE
WE ARE NEARING HERE
WE ARE NOW OPEN TO TAKING ANY QUESTIONS
WE ARE REACHING THE END OF THE PRESENTATION NOW SO LET'S SUMMARISE
WE ARE READING THE VALUE WITH THE SENSOR CONTINUOUSLY BUT IF THE VALUE IS SMALLER THAN THE MINIMAL DISTANCE THAT WE DECIDED THEN WE ARE GOING TO STOP THE WHEELS AND I'M GOING TO SHOW A BIT LATER HOW TO STOP THE WHEELS AND THEN CHECK THE DISTANCE ON THE RIGHT
WE ARE RUNNING OUT OF TIME
WE ARE TALKING MORE ABOUT THIS
WE AREN'T GOING TO NEED THAT
WE ASKS IT TO EMIT ASSEMBLER AND THE RUST COMPILER DUTIFULLY COMPLIES AND WE GET THIS CODE WHICH IS SIGNIFICANTLY DIFFERENT FROM OUR BROKEN CODE
WE BELIEVE IT IS IMPORTANT TO KEEP THE COMMUNITY ALIVE AND MAKE SURE THERE IS CONSTANT INNOVATION AND THAT PEOPLE ARE ALWAYS ENGAGED
WE CALL IT PCINT0 BECAUSE IT'S AN INTERRUPT ON THE PIN CHANGE
WE CALL THE CODE THAT EMULATES A FUNCTION AN SHIM
WE CALL THIS CUSTOM TYPED SYSTEM DEVELOPED AS PART OF OUR PROJECT NETWORK PACKET REPRESENTATION
WE CAN ALSO CLEAR A REGISTER
WE CAN ALSO LOOK AT LIKE MORE AT THE COMPILER LEVEL WHAT DO WE NEED TO DO IN A COMPILER TO ACTUALLY DO IT RIGHT
WE CAN ALSO REPLACE THAT WITH A PANIC
WE CAN ARGUE THAT OF COURSE THIS WORKED REQUIRED A LOT OF EXPLORATION BECAUSE OF HOW STYLISED IT IS THEREFORE THE SEARCH WAS PURELY ABOUT FINDING THE STYLISATION AND RE IMAGINING WHAT WE SEE INTO SOMETHING COMPLETELY DIFFERENT
WE CAN ASK THE COMPUTER TO COUNT TO A NUMBER FOR US AND�LET US KNOW WHEN IT GETS TO IT
WE CAN AUTOMATICALLY GENERATE THIS AS A WRAPPER UNDER AN UNSIGNED SIXTEEN BIT INTEGER IN A RUST OUTPUT FILE EASILY
WE CAN CALL THESE CONSTRAINT TYPES SINCE THEY NEED TO BE CHECKED
WE CAN CLICK ON THE RUN BUTTON IN ANY OF THE EXAMPLES AND YOU WILL BE DIRECTED TO THE RUST PLAYGROUND WHERE WE CAN SEE THE OUTPUT
WE CAN CONSIDER A VIDEO STREAMING APPLICATION WHERE YOU MIGHT NEED TO HAVE ACCESS TO A NETWORKING PERIPHERAL THAT YOU CAN USE TO FETCH A VIDEO FROM SOME SERVICE
WE CAN DO IT IN MERE SECONDS
WE CAN EASILY DECOMPOSE EACH RGC OR CMYK AND UTILIZE THEM APPROPRIATELY
WE CAN EXTEND THIS TO A COMPLEX TWO D POLYGON DESCRIBED BY A SERIES OF POINTS
WE CAN GO INTO THE DOCUMENTATION
WE CAN HOLD THIS INFORMATION IN A CONTEXT DATA TYPE WHICH CAN BE RECEIVED BY OTHER PROTOCOL DATA UNITS WHICH ALSO FEATURE IN THIS DRAFT IF REQUIRED
WE CAN IMAGINE THAT PROBABLY SOME OF THE SCHEMA CHECKING ET CETERA WILL BE DONE IN PROLOG EVEN THOUGH IT WILL BE PERHAPS PROLOG EMBEDDED IN RUST OR USING SCRYER FOR PROLOG OR SOMETHING ALONG THOSE LINES
WE CAN IMPROVE IN RUST
WE CAN JUST READ STUFF FROM IT
WE CAN LOOK AT THIS BOTH IN KIND OF THE PROGRAMMING CONTEXT AS WELL AS THE MORE GENERAL CONTEXT OF WHAT EAGERNESS MEANS RIGHT
WE CAN ONLY READ STUFF FROM IT
WE CAN RECORD EACH STATE AT EACH STEP AND MOVE IT FORWARDS AND BACKWARDS IN TIME
WE CAN SEE THAT THE THERE IS PROBABLY SOMETHING THERE
WE CAN SIMPLIFY THIS TABLE FURTHER AND SAY THAT THE NUMBER IS LIKELY TO BE NEAR 0
WE CAN TAKE THE CPU AND SEE WHAT IT LOOKS LIKE ON THE INSIDE
WE CAN THINK OF A COMPUTER AS BEING A BOX
WE CAN THINK OF OUR EFFECTS ON THE WORLD AS COMING ON THOSE PERIPHERALS
WE CAN THINK OF THAT IN THE MORE GENERAL SENSE OF WHAT THE WORD EAGER MEANS
WE CAN USE THIS TRICK
WE CAN WRITE CODE FOR AN EMBEDDED CONTEXT THAT DOESN'T NEED TO KNOW DETAILS ABOUT THE
WE CAN'T HEAR YOU AT THE MOMENT
WE CAN'T INTERPRET THAT IN ANY WAY
WE CAN'T WORK WITH THAT
WE CANNOT GROW IT OR MAKE IT SMALLER
WE CHOSE THIS TIME TO LEAVE IT IN MEMORY FOR THE SIMPLICITY OF DESIGN AND PERFORMANCE
WE COME TO THE CER WHICH IS DECENTRALIZED SELF SCHEDULING JIT COMPILATION BASED KERNEL
WE CONSIDER ALTERNATIVE TO JIT COMPILATION CHOICES
WE CONSTRUCT AN ASSEMBLY DIRECTIVE WHICH DATES THIS MASK VALUE AS AN INPUT AND ALSO TAKES THIS MASK VALUE AS AN OUTPUT
WE COULD MAYBE COME UP WITH MORE ADVANCED TESTING AND AUTOMATED ERROR CORRECTION LATER ON POSSIBLY BUT THAT'S GOING TO TAKE SOME TIME TO DEVELOP
WE COULD TRY SUBTRACTING EACH BYTE FROM THE LAST SO THAT INSTEAD OF SEEING MOVES IN ABSOLUTE COORDINATES WE WILL SEE THEM IN RELATIVE COORDINATES
WE CREATE THE ANIMAL TRAIT WHICH HAS THE SOUND METHOD WHICH DOG WILL NOW IMPLEMENT INSTEAD OF THE BARK METHOD
WE DECIDED TO CREATE A BOOK FOR SPACE SHOOTER AS A CENTRAL LOCATION FOR DOCUMENTATION
WE DECIDED WE WERE JUST GOING TO TAKE THE PLUNGE AND REWRITE THE FOUNDATIONS OF OUR SYSTEM IN RUST
WE DECLARE MUTABLE TRIGGER THAT I CONNECTED TO PIN D12 AND CONFIGURED INTO OUTPUT
WE DEFINE THE DEFAULT SPEAK IMPLEMENTATION IN THE DECLARATION FOR THE ANIMAL TRAIT
WE DEFINITELY BUILD A RELEASE BUG ALWAYS AND IT IS A TREMENDOUS SPEED UP BETWEEN THEM
WE DESIGN THE STRUCTS
WE DID THIS BY HAVING DISCUSSIONS ON GITHUB ISSUES AND CODE REVIEWS
WE DIDN'T HAVE ANY RUST IN OUR DEVELOPMENT AT ALL
WE DISCUSSED HOW CODE AS AN ART MEDIUM INVITES US TO CONVEY OUR SEARCH PROCESS IN AN ALGORITHMIC FORM MAKING IT THE MAIN ART PIECE
WE DO HAVE A COUPLE OF QUESTIONS FROM THE AUDIENCE WHICH IS GREAT
WE DO IT QUICK BECAUSE IT IS LATE
WE DO THOSE ON DATABASES
WE DON'T ALWAYS THINK OF THE THINGS HAPPENING AT THIS LEVEL OF ABSTRACTION IN TERMS OF SERIALIZATION BUT IT IS SERIALIZATION JUST THE SAME
WE DON'T EVEN KNOW ANY MORE
WE DON'T HAVE DYNAMIC EVALUATIONS IN CONST EVAL
WE DON'T THINK MUCH MORE
WE DON'T WANT TO DO THAT BECAUSE IT ALSO ALLOWS YOU TO MAKE MORE MISTAKES AND WE WANT OUR CRYPTO CODE TO BE REALLY SECURE SO WE WOULD LIKE TO USE A HIGH LEVEL LANGUAGE IF THAT IS AT ALL POSSIBLE
WE DON'T WANT TO LEAK ANY INFORMATION ABOUT THE SECRET VALUE SO THE RUNTIME OF THIS FUNCTION SHOULD BE ALWAYS THE SAME LENGTH THE SAME DURATION LIKE DEPENDING ON THE VALUE OF THIS CONDITIONAL VALUE
WE DOWNLOAD EVERYTHING WE HAVE ON THE MCU
WE ESSENTIALLY REWRITE THE KIND OF FEATURE THAT WE ARE INTERESTED IN THERE AND THEN INSTEAD OF JUST IMMEDIATELY GOING TO RUST FROM THERE WE ACTUALLY WAIT SO WE'RE MUCH MORE SELECTIVE ABOUT WHAT WE PUT INTO RUST THAN WE HAD INITIALLY IMAGINED
WE ESTABLISHED SHORT TERM GOALS
WE FIND THAT THERE ARE MORE TCP OPTION VARIANTS SO WE REPEAT THIS PROCESS FOR EACH ONE
WE FIRST NEED SEPARATE THE DATA SO LOGICALLY RELATED DATA ARE STORED LOCALLY
WE FORGOT IN THIS CASE THAT'S EXACTLY WHAT RUSTC TELLS US
WE FOUND IN CERTAIN AREAS OF THE INDUSTRY OUR CUSTOMERS DIDN'T KNOW WHAT COLOR THEY WANTED OR WERE NOT ABLE TO GIVE US AN RBG OR A CMYK COLOR THEY WANTED
WE GENERATE A CUSTOM TYPE AND
WE GENERATE A CUSTOM TYPE AND PARSER WHENEVER WE REACH A LEAF NODE AND GENERATE A PARSER COMBINATOR FOR THE PARENT NODES WHEN THERE ARE NO MORE LEAF NODES FOUND FOR THAT PARENT
WE GOT DATA PARALLELISM FROM SWITCHING TO RUST AT A VERY LOW COST USING RAYON AND IT REALLY BLEW OUR MINDS
WE GOT SO MUCH SPEED OUT OF IT SO YES RUST'S ECOSYSTEM IS JUST AMAZING
WE HAD SOME TECHNICAL DIFFICULTIES SOMETIMES WHICH ONE DOES WITH THIS ONLINE EXPERIENCE I WOULD SAY ALSO IT'S KIND OF FUN EXPERIENCES NOW I HAVE TO SAY
WE HAD THE LOGIC WRITTEN THERE AND WE USED THESE MAGIC INCANTATIONS INTO PAR AND OTHERS AND EVERYTHING IS WAY WAY FASTER
WE HAD THINGS WE HARDLY CHANGED AT ALL
WE HAD WE HAD A COMFORTABLE INTERACTION WITH C STACK AND THIS IS ANNOYING BECAUSE IF WE'RE INTERFACING WITH RUST WE'RE ACTUALLY INTERFACING IT THROUGH A C FFI AND THAT KILLS SOME OF THE NICE GUARANTEES YOU GET FROM RUST BUT AT LEAST THEY'RE ISOLATED TO THE INTERACTION SURFACE RATHER THAN COMPLETELY
WE HAVE A BUNCH OF GIT LIKE FEATURES LIKE REVISION CONTROL PUSH PULL CLONE AND ALL OF THE THINGS THAT YOU KNOW FROM GIT
WE HAVE A CARGO FILE HERE THAT IS FOR EXAMPLE PACKAGE
WE HAVE A COUPLE QUESTIONS
WE HAVE A DATA LOG QUERY ENGINE AND WE ALSO HAVE COMPLEX SCHEMA CONSTRAINT MANAGEMENT
WE HAVE A DATASET AND A GAME OF GO AND WE WANT AN ALGORITHM TO PREDICT THE NEXT MOVE INTO THE GAME
WE HAVE A FUNCTION ON THE LEFT A AND THE FUNCTION ON THE RIGHT B
WE HAVE A PEER REVIEWED PUBLICATION WHICH GOES INTO MORE DETAIL ABOUT OUR NETWORK PACKET REPRESENTATION TYPING SYSTEM AND A GITHUB REPOSITORY CONTAINING THE CODES FOR ALL AUTOMATIC RUST PARSER GENERATOR
WE HAVE A PROLOG AND EPILOGUE FOR EVERY FUNCTION
WE HAVE A QUESTION FROM THE CHAT WHICH IS ARE THERE ANY RUST PARADIGMS THAT HAVE BEEN GETTING IN THE WAY FOR THIS PROJECT
WE HAVE A RUSTC FRONTEND AND AN LLVM BACKEND
WE HAVE A SET OF REGISTERS AND SOME MEMORY
WE HAVE A TEST AND THE TEST PASSES
WE HAVE A THIS IS TAKEN FROM THE TRACING GRID
WE HAVE A TOOL CALLED RUSTDOC
WE HAVE A USER THAT IS CONCISE WITH AN INDEX IT WANTS TO USE FROM A CONFIG FILE
WE HAVE ALL STORAGE LAYER BECAUSE POPULAR STORAGE AND THE COMPUTER SEPARATION IS GENETICALLY LESS EFFICIENT
WE HAVE AN ALLOCA AND THAT MAKES THE CODE FAIL
WE HAVE AN IN OPERATION WHICH WILL TAKE A VALUE FROM A
WE HAVE BEEN THROWING AROUND THE EARLY ECS
WE HAVE BEEN USING IT FOR VARIOUS THINGS
WE HAVE FOUND FOSTERING THIS KIND OF CULTURE HAS BEEN VERY VERY IMPORTANT TO THE SUCCESS OF USING RUST WITHIN OUR DEVELOPMENT TEAM
WE HAVE FOUND ONCE PEOPLE GET USED TO TALKING TO THE COMPILER THEY DON'T NEED VERY MUCH HAND HOLDING
WE HAVE FUNCTION A ON THE LEFT AND AN INTERRUPT SERVICE ROUTINE ON THE RIGHT
WE HAVE LISTED LIBRARIES WE HAVE USED AND HAD GOOD EXPERIENCES WITH THEM
WE HAVE ONE QUESTION
WE HAVE ONE QUESTION FROM THE PUBLIC
WE HAVE PARALLELIZATION REPRESENTATION FOR MULTI CORES
WE HAVE REALLY BEEN PERFORMANCE DRIVEN ON THIS SO THE THINGS THAT GET PRESSED INTO RUST ARE THOSE THINGS THAT NEED PERFORMANCE ENHANCEMENTS
WE HAVE RUST ANALYZER WHICH IS A RELATIVELY NEW TOOL
WE HAVE RUST AND WE HAVE PROLOG WHICH IS SOMEWHAT UNUSUAL IN THE MODERN DAY
WE HAVE SEEN HOW THE CHOICES IN THE REPRESENTATION OF DATA CAN HAVE A SIGNIFICANT IMPACT ON THE SPEED SIZE AND ENGINEERING EFFORT AND CAPABILITIES
WE HAVE SOME SORT OF MATH EXPRESSION HERE AND WE'RE TESTING IT AGAINST THIS SORT OF KNOWN VALUE
WE HAVE STAR CONST AND STAR MUT AND THEY EXIST BECAUSE THEY DON'T FOLLOW THE SAME RULES AS REFERENCES
WE HAVE SWUNG THE LIMIT ON THE LIFETIME
WE HAVE TALKED ABOUT ART AS A SEARCH PROCESS FOR NEW REPRESENTATIONS AND HOW REPRESENTATIONS CAN INVITE US TO VIEW THE SAME OBJECT FROM DIFFERENT PERSPECTIVES
WE HAVE THE ABSTRACT ANIMAL CLASS
WE HAVE THE COMPRESSION RATIO WHICH IS HOW SMALL THE FILE IS PERFORMANCE IS HOW FAST WE CAN READ AND WRITE THE FILE AND THE DIFFICULTY IS THE LEVEL OF ENGINEERING EXPERIENCE IT TAKE
WE HAVE THE CONS AND EMPTY FUNCTIONS AVAILABLE TO STUDENTS SINCE THEY'RE TYPICALLY WHAT THEY'RE USED TO COMING FROM RACKET
WE HAVE THE CUSTOM PROTOCOL TYPING SYSTEM DEVELOPED IN STAGE 2 OUR NETWORK PACKET REPRESENTATION LANGUAGE
WE HAVE THE DOG STRUCT WHICH HAS FIELDS THAT USE ALL OF THE DIFFERENT BASIC DATA TYPES THAT WE TALKED ABOUT EARLIER
WE HAVE THE FILTER METHOD NOW WHICH ACCEPTS A PREDICATE WHICH AS YOU CAN SEE AT THE VERY TOP OF THE FILE IS A TYPE ALIAS TO A FUNCTION THAT ACCEPTS A REFERENCE AND RETURNS A BOOLEAN
WE HAVE THE ILIST INTERFACE AND THE CONS AND CLASSES THAT IMPLEMENT THE INTERFACES
WE HAVE THE IMPLEMENTATION OF INNER MODULE
WE HAVE THE LOAD FUNCTION WHICH HAS MULTIPLE REQUESTS AND ERROR UNKNOWN AND THIS MEANS THAT THERE IS MORE CONTEXTUAL DATA ADDED TO YOUR LOGS RATHER THAN A SINGLE LOG MESSAGE THAT IS VERY HARD TO COMPREHEND ON WHICH LIFECYCLE
WE HAVE THE MACHINE READABLE PROTOCOL DOCUMENT AT STAGE ONE WITH OUR MINIMAL CHANGES TO ASCII DIAGRAMS AND TEXT DESCRIPTIONS
WE HAVE THE MAKERS OF LINKERD
WE HAVE THE SAME SIMILAR PROGRAM HERE THAT RUNS IN A LOOP ESSENTIALLY
WE HAVE THERE WORKSPACE INCLUDING ALL THESE TRACINGS AND THEY CAN BE BINARY OR LIBRARY PLATES
WE HAVE THESE OPERATIONS AND YOU DON'T EVEN SEE THEM IN THE COMPILED CODE BECAUSE LLVM IS SMART ENOUGH TO SEE THAT THEY'RE NOT NEEDED
WE HAVE THIS OPEN
WE HAVE THIS OTHER INTERFACE BUFFER WHICH HAS A BYTE ARRAY AND A COUNT OF HOW MANY ITEMS ARE WRITTEN IN THE ARRAY
WE HAVE THIS UNSAFE BLOCK
WE HAVE THREE MINUTES
WE HAVE TO COMPILE THAT IN DEBUG MODE TO GET THE SYMBOLS OUT
WE HAVE TO FIGURE OUT HOW TO READ THEM RIGHT
WE HAVE TO IMPLEMENT THESE INSTRUCTIONS ON THE SECRET TYPES SO THAT WILL ACTUALLY BE A LOT OF WORK
WE HAVE TWO DIFFERENT REPRESENTATIONS OF THE SAME PROGRAM
WE HAVE TWO SORT MANY WAYS TO COMPLETE THE PROBLEM
WE HAVE VECTOR WITH THREE ELEMENTS AND WE'RE TRYING TO GET THE TENTH ONE
WE HAVEN'T FOUND ANY ISSUES WITH THAT SO FAR
WE HOPE TO KEEP A GOOD SIGNAL SO IT IS HIGHLY HACKABLE
WE HORIZONTALLY SCALE UNTIL WE CAN HANDLE IT
WE IN FACT IN MY PRESENTATION WE JUST MAY I PRESENT HERE IS THE PROBLEM WE COULD IMPROVE IN RUST
WE JUST DEPEND ON WHAT WE WANT TO REVIEW
WE JUST DON'T KNOW YET WHAT IT IS
WE JUST GIVE THE SIMPLE SUMMARY HERE
WE JUST LEAVE SOME ENTRY SO YOU CAN THINK
WE JUST NEED THE TENSOR WERE THE 60 MILLISECONDS TO SCAN OVER THE MEMORY
WE JUST NEED TO BUILD THE TOOLING AROUND IT
WE JUST UNLOCK THE OBJECT AS WE WANT
WE JUST WHEN WE SCAN OVER THE MEMORY WE DO SOMETHING TO GET A RESULT AND HERE IS JUST YOU CAN SAY THE SLEEP HERE IS JUST THAT WE CAN TURN THE QUERY TO THE TITLEAL TITLE OF THE CORNER
WE KNOW STATICALLY THE RESULT IS NEVER THE ERROR CASE
WE KNOW THAT NOTHING HAPPENS INSIDE AN ASSEMBLY DIRECTIVE BUT LLVM CANNOT REASON ABOUT THAT
WE LEAVE OUT THE INTERFACE FOR BUFFER AND HOLD THE BYTE AWAY AND COUNT
WE LOSE THIS GUARANTEE THAT RUST HAS THAT OF PRODUCING PROGRAMS THAT DO WHAT WE WANT THEM TO DO
WE LOVE IT
WE MAY HAVE ENOUGH TIME
WE MAY KNOW TO USE THE POPULAR CPO BUT WHAT WE WANT IS DATA DRIVEN AND LOW ENTROPY INFERENCE HERE
WE NEED A WAY FOR THE GAME TO UPDATE THE VALUES OF A HEALTH COMPONENT WHEN DAMAGE IS DEALT TO THE ENTITY THAT IT'S ATTACHED TO
WE NEED TO ADD AN OPTIMISATION BARRIER TO THIS MASK VARIABLE
WE NEED TO MINIMIZE OUR REPRODUCTION OF THE BUG
WE NEED TO PUT IN MORE WORK ON FUNCTION TYPES SO WE CAN CREATE ENCRYPTION AND DECRYPTION FUNCTIONS FOR PROTOCOLS LIKE QUIC WHICH HEAVILY RELY ON THIS
WE NEED TO RENDER EVERY FRAME
WE NEED TO SEND SOUND WAVES ABOUT EVERY 100 MILLISECONDS
WE NEEDED
WE NEEDED TO ANNOTATE THE STRUCTS AND MOVE ALL ERROR PRONE WORK INTO THE COMPILER
WE NEEDED TO HAVE A CODE OF CONDUCT TO ESTABLISH A SAFE ENVIRONMENT TO CONTRIBUTE AND LEARN
WE NEEDED TO HAVE A CONTRIBUTING GUIDE FOR THOSE INTERESTED IN ADDING CODE
WE NOTE THAT LITTLE SEQUENCE IS INTERRUPTED BY THIS SECTION 14 15 AND 17
WE NOW WANT TO ADD THE CAT STRUCT
WE POP 24 YOU ARE A OF THE STACK
WE POP THE STATUS VALUE OFF OF THE STACK AND WE USE AN OUT COMMAND TO PUT IT BACK IN
WE PROVIDE A TARGET THAT GUIDES OUR SEARCH TO A SPACE CONTAINING SIMILAR IMAGES AND THE WAY WE CAN DEFINE SIMILARITY IS SIMPLY A DIFFERENCE BETWEEN THE PIXELS OF THE TARGET AND THE PIXELS OF THE DRAWN IMAGES
WE PROVIDE HUMAN READ
WE SAID PREVIOUSLY WE CLOBBER 28 AND 29
WE SAID THAT THE COMPUTATION COMES FROM
WE SAID THE PROCESS IS THE BRAINS OF THE COMPUTER
WE SAW OUR EMIT THE SPECIAL EPILOGUE CODE HERE
WE SCALE UP TO QUITE LARGE GRAPHS
WE SEE 27
WE SEE 28 THAT'S STILL A POP KEEP GOING
WE SEE AT THE BOTTOM THE BRICK WALL AT THE BOTTOM IS OUR PROGRAM THAT'S BEEN LOADED
WE SET A BREAK POINT AT LINE 8
WE SET THE INDEX TO 1 BECAUSE WE WANT TO RUN THAT AND WE DISABLE THE ISOLATION
WE SHOULD ADDRESS COMPONENT STORAGES
WE SHOULD CAREFULLY MAKE TRADE OFFS IN PERFORMANCE OR FUTURE
WE SHOULD DEFINE WHAT THE EXPECTED BEHAVIOR OF AN ENTITY SHOULD BE
WE START RUNNING AND BASICALLY DECIDE THAT WITHIN 2 MONTHS YOU WANT TO RUN A MARATHON
WE STARTED USING TOWER G REC PC BECAUSE LINKERD WAS USING IT
WE SUBTRACT 1 FROM THE FRAME POINTER
WE TAKE SOME VALUE ON THE REGISTER AND PUT IT ON THE STACK TO SAVE IT FOR LATER
WE TEND TO USE FILES WE TEND TO ACCESS FILES GET RESOURCES OVER THE NETWORK INTERACT WITH DATABASES WE NEED TO GO TO THE PRIMITIVE OF OUR SYSTEM WHATEVER
WE TOOK A STEP BACK AND EXAMINED THE BASICS OF ECS
WE TOOK THAT OPPORTUNITY TO ALSO EXPAND OUR COMPUTER MODEL A BIT
WE TRY AND CONVERT THE NUMBER BUT IF IT WOULDN'T FIT WE STOPPED EXECUTION
WE USE A TURBOFISH TO THAT
WE USE DECENTRALIZED
WE USE IT FOR OUR FONT FORMATS AND AS WELL AS EMOJI
WE USE MONEY IN ENTERPRISE AND WE USE MULTIPLE CURRENCIES AND SO IF WE WERE TO HAVE A MONEY STRUCT HERE OF COURSE WE WOULD HAVE AN AMOUNT AS SOME KIND OF DECIMAL VALUE AND THE CURRENCY COULD BE HELD AS SOME KIND OF STRING BUT THAT WOULD REQUIRE US TO DO RUN TIME CHECKS WHICH ARE OF COURSE SOMETIMES NECESSARY BUT WHEN WE HAVE BUSINESS LOGIC CODED IN WE OFTEN WANT TO HAVE COMPILE TIME CHECKING
WE USE RABBITMQ REDIS AND POSTGRES AND GRPC
WE USE THIS NOT JUST FOR MONETARY TYPES BUT ALSO FOR PHYSICAL TYPES SUCH AS METERS LENGTH VERSUS VOLUME VERSUS AREA
WE USED USING NUM FUNCTIONS AS OPPOSED TO MACROS SO WE KNEW WHAT WAS GOING ON
WE WANT TO USE RUST
WE WANT TOP PERFORMANCE
WE WANTED TO AVOID COMPONENTS THAT WERE BLOATED REDUNDANT DATA AND AS A RESULT DIFFICULT TO USE
WE WENT IN WE REPLACED THE FOUNDATIONS AND THEN WE WERE GOING TO START REPLACING THE WALLS SO UNFORTUNATELY DEVELOPER TIME CONSTRAINTS HAS FAVOURED A DIFFERENT APPROACH FOR US SO WE'RE DOING RAPID PROTOTYPING IN PROLOG
WE WERE GETTING SEGFAULTS AND WE WERE FINDING IT DIFFICULT TO TIME CONSUMING TO SORT IT OUT
WE WERE SCARED TO TRY IT BECAUSE OH DATA PARALLELISM SCARY BUT IT'S LITERALLY JUST REPLACING A FEW CALLS AND IT JUST WORKS
WE WILL BE BACK IN EIGHT MINUTES I WOULD SAY
WE WILL BE IN THE CHAT
WE WILL GET TO THAT LATER
WE WILL GO INTO THAT LATER
WE WILL HAPPILY TAKE FEEDBACK IF PEOPLE WANT TO IMPROVE OUR PARSERS SO I CONSIDER MYSELF A NOVICE AT RUST
WE WILL LOAD THAT INTO MEMORY AND THEN WE WILL GO AHEAD AND START EXECUTING FROM THERE
WE WILL LOOK AT A COUPLE OF HACKS THAT WE COULD USE TO PREVENT SOME OF THESE CHANNELS IN RUST
WE WILL LOOK AT SOME PROPERTIES INHERENT TO THE DATA REPRESENTATIONS USED BY SPECIFIC SERIALIZATION FORMATS AND SEE HOW THE FORMATS EITHER HELP US SOLVE A PROBLEM OR GET IN THE WAY
WE WILL SEE AN EXAMPLE
WE WILL SEE YOU IN THE CHAT
WE WILL SEE YOU IN THE CHAT RIGHT
WE WILL TRY TO INSTALL THE CARGO EXPAND BINARY
WE WILL USE THE GAME OF GO AS A BASELINE AGAINST TREE BUF
WE WILL WRITE THE PROGRAM IN TWO LANGUAGES
WE WOULD LIKE TO USE THE RUST LIBRARIES FOR PROTOCOL AND ERROR CORRECTION TO SUPPORT MORE PROTOCOL LANGUAGES IN THE FUTURE
WE WOULD LOVE THAT
WE WOULD USE A TIMER AND ANOTHER TIMER TIMER 1
WE WRITE DOWN SOMEWHERE WHATEVER NUMBER IS ON IT AND MAKE IT TO ERASE IT
WE'LL ALSO BE TALKING ABOUT THINGS THAT I'M RELATIVELY AN AMATEUR ABOUT
WE'LL BE TALKING ABOUT SOME COMPLEX SYSTEM
WE'LL TALK ABOUT EACH OF THESE FOUR IN TURN A LITTLE BIT LATER
WE'RE GOING TO ALLOW STUDENTS TO USE FUNCTIONS SOMETHING THEY CAN'T CURRENTLY DO IN JAVA SINCE THAT PROVIDES A LOT OF GREAT FUNCTIONALITY FOR PROGRAMS
WE'RE GOING TO CONTROL THE DUTY CYCLE
WE'RE GONNA LOAD PROGRAM INTO MEMORY
WE'RE GONNA REMOVE ANY OTHER CRATES THAT I MAKE USE OF
WE'RE GONNA REMOVE OF COURSE THE CRATE THAT I WAS WRITING EXAMPLE CODE FOR
WE'RE GONNA SAVE WORKING REGISTERS THAT WE NEED TO SAVE
WE'RE JUMPING INTO AN INTERRUPT SERVICE ROUTINE
WE'RE JUST LIKE THIS IS GRAVY FOR US
WE'RE JUST PRINTING SOMETHING IN UNSAFE
WE'RE LUCKY ENOUGH TO HAVE YOU BOTH HERE FOR A Q AN A
WE'RE NOT IN COMPETITION
WE'RE NOT JUMPING INTO A FUNCTION ON STEP 2
WE'RE NOT JUST SPLATTERING A UNIFORM BRUSH TEXTURE BUT HAVE A SPECIFIC THOUGHT PROCESS MANIFESTED IN THE WAY THE BRUSHES NON UNIFORM SIZES AND VISUALLY INTERACTING WITH EACH OTHER
WE'RE NOT SURE WHAT THE STATUS OF THAT WORK IS AT THE MOMENT BUT WHAT LLVM NEEDS TO DO IS TO MAKE SURE THAT OUR CONSTANT TIME RUST CODE IS ALSO COMPILED SAFELY
WE'RE NOT SURE WHY THAT IS WRONG REALLY RIGHT NOW
WE'RE RESERVING SPACE ON THE STACK FOR THE LOCAL VARIABLE
WE'RE STILL LEARNING ECS
WE'RE TRYING TO GET THE TENTH ELEMENT OF A VECTOR WITH ONLY THREE
WE'RE USING AN EIGHT BIT MICROCONTROLLER
WE'RE WIRING UP A MICROCONTROLLER AND CONNECTING IT TO A AN LED
WE'RE WORKING IN A PANIC ABORT MODEL FREQUENTLY
WE'VE ALSO OFTEN CONSIDERED HERE IN LATIN AMERICA STARTING
WE'VE GOT OUR BASIC BUILDING BLOCKS SORTED OUT
WE'VE GOT SEVEN TYPES IN TOTAL IN OUR NETWORK PACKET REPRESENTATION SYSTEM
WEBASSEMBLY DOES NOT HAVE THIS PROBLEM
WELCOME TO MY TALK TITLED THE ANATOMY OF ERROR MESSAGES
WELCOME TO RUSTFEST GLOBAL 2020
WELL ALMOST EMBARRASSINGLY IT'S THE SAME AS LEARNING PROGRAMMING LANGUAGE
WELL AS WE SAW PREVIOUSLY FIRST WE PUSH THE 28 AND 29 REGISTERS ON TO THE STACK
WELL AVR IS TIER 3
WELL COLTON THANK YOU SO MUCH FOR YOUR TALK
WELL HERE WE SEE THE PROLOG AND THE EPILOGUE OF OUR WORKING CODE
WELL HERMES CONRAD ONE OF MY FAVORITE CHARACTERS FROM FUTURAMA IF YOU WANT IT DO IT
WELL I CAN ONLY REMEMBER THAT WHEN I STARTED TO LEARN RUST THE FIRST PROGRAM I WANTED TO WRITE WAS A WORD COUNTER
WELL I EXPECT THAT LIKE ME FOR MOST OF YOU THE BULK OF YOUR SOFTWARE DEVELOPMENT EXPERIENCE IS ON THE DESKTOP OR SERVER
WELL I MEAN IT IS FAST ENOUGH IT'S FAST ENOUGH WHEN WE'RE JUST TESTING OUT THINGS
WELL I'M GONNA SAY IT
WELL IT REFERS TO THE MANUFACTURING PROCESS THAT GIVES US THESE GOODIES IN LIFE
WELL IT'S ANOTHER REPRESENTATION OF A PROGRAM
WELL LIKE TYPES JUST INTRODUCE EXTRA OVERHEAD
WELL THAT WAS A WHIRLWIND
WELL THE FIRST THING IS THAT WE DON'T
WELL THERE'S THIS THING CALLED A CALLING CONVENTION
WELL THEY DID A BUNCH OF RESEARCH ON STUDENTS LOOKING INTO WHAT IS
WELL THIS MAYBE IS A CLUE BUT DOESN'T PROVIDE A LOT OF INFO BECAUSE WE KNOW ISR
WELL THIS QUESTION OF LIKE YOU KNOW HOW ARE RUST'S ERROR MESSAGES SO HELPFUL RIGHT
WELL WE DON'T HAVE MORE TIME SORRY
WELL WE'LL GO AHEAD AND ADD ONE TO OUR UPDATED FRAME POINTER IN REGISTERS 28 AND 29
WELL WE'RE GONNA DO A LOOP
WELL WHAT DOES IT LOOK LIKE IN OUR BROKEN CODE
WELL WHAT DOES THAT EXACTLY MEAN TO MIRROR EACH OTHER
WELL WHY IS IT THAT TOGGLE RETURNS A RESULT
WHAT ABOUT ANY MISSING ERROR MESSAGES
WHAT ABOUT EASE OF USE AND ENGINEERING EFFORT
WHAT AN AMAZING TALK REALLY
WHAT ARE RAW POINTERS
WHAT ARE YOUR FAVORITE WAYS TO INTEGRATE RUST WITH PYTHON
WHAT DO I MEAN BY THAT
WHAT DO YOU THINK ABOUT A NATURAL NEXT STEP TO SPEED UP PYTHON CODE
WHAT EXACTLY IS LEARNABLE PROGRAMMING
WHAT HAPPENS IS THAT MIRI LETS THE COMPILER RUN UNTIL YOU HAVE THE REVIEW PROGRAM AND WE INTERPRETS THAT
WHAT HAPPENS WHEN YOU CALL A FUNCTION
WHAT I ALWAYS RECOMMEND IS TO DANCE WITH RATHER THAN TO EVADE BECAUSE FOR HIGH PERFORMANCE SYSTEM YOU NEED TO THINK CAREFULLY ABOUT RESOURCES MANAGER
WHAT I SUGGEST IS USE THE NIGHTLY AS POSSIBLE
WHAT I WANT YOU TO NOTICE IS THREE HORIZONTAL LINES RIGHT NEAR CENTER
WHAT IF WE COULD USE THE CHECKMARK FROM GZIP TO THE DELTA COMPRESSION METHOD
WHAT IS CARGO
WHAT IS GREAT WITH THE BRAND IS THE ECOSYSTEM
WHAT IS IT THAT'S BETWEEN THESE TWO BOXES
WHAT IS METAL FABRICATION ANYWAYS
WHAT IS PIPES
WHAT IS THE OUTPUT OF THIS COMPILER
WHAT IS THIS ALLOCA THAT WE SEE
WHAT IS THIS LIMITATION IN RESOURCES IMPLY FOR EACH OF THESE COMPONENTS
WHAT IS UNDEFINED BEHAVIOUR AND HOW EVERYTHING WORKS IN RUST
WHAT IT DOES IS LOOKS AT WHAT IF WE WOULD REPLACE ALL OF THE INTEGER TYPES THAT IS CONSTANT TIME INTEGER TYPE WOULD THAT WORK
WHAT IT TRIES TO DO IT ACTUALLY
WHAT KIND OF DOCUMENTATION DO WE HAVE
WHAT MADE IT DIFFICULT TO LEARN DIFFERENT THINGS
WHAT MISSING TEACHES
WHAT RUST GIVES YOU IS MUCH MORE
WHAT THE ERROR IS IN YOUR CODE
WHAT THE IMPROVING PROTOCOLS STANDARD AIMS TO DO IS TO PROVIDE A MACHINE READABLE ASCII FORMAT TO DETECT THESE INCONSISTENCIES MUCH MORE EASILY
WHAT THEY ARE
WHAT THIS MEANS IS THAT YOU DON'T HAVE ACCESS TO THE STANDARD LIBRARY
WHAT WE ARE LOOKING FOR HERE IS WHAT IT HAPPENING IN THE EXECUTION OF MIRI IS THAT THIS FUNCTION IS CREATING A POINTER THAT IS DANGLING
WHAT WE FOUND WAS WITH THE BIT LEVEL PARSERS IT TENDS TO GO STRAIGHT INTO THE NEXT BYTE IF YOU HAPPEN TO IF THE COUNTER EXCEEDS SEVEN SO IT WILL JUST RUN FORWARDS HAPPILY
WHAT WE HAVE IS FANTASTIC PERFORMANCE AND COMPRESSION
WHAT WE MEASURED IS RELATIVE CPU TIME TO ROUNDTRIP THE DATA THROUGH SERIALIZED AND DESERIALIZED
WHAT WE NEED TO DO IS TO IMPROVE RUST DOC TO AUTOMATICALLY GENERATE PLAYGROUNDS FOR OUR DOCUMENTATION AND WE ALSO NEED TO HAVE A TOOL KIT TO SIMPLIFY BUILDING THESE INTERACTIVE PLAYGROUNDS
WHAT WE SAW IN OUR ASSEMBLER
WHAT WE SEE WHEN LLVM COMPILES THIS RUST COMPILES IT THAT THE COMPILER IS SMART
WHAT WE WILL NEED TO DO IS TO BASICALLY COPY MEMORY FROM MODULE A TO MODULE B BEFORE WE CAN CALL AN IMPORTED FUNCTION
WHAT WE'VE DONE FOR SHOWING THE TCP EXAMPLE WE'VE GONE THROUGH AN OLDER RFC AND MADE MINIMAL CHANGES TO IT TO GENERATE PARSERS SO IF YOU WANTED TO DO THAT WITH PROTOCOLS THAT'S ABSOLUTELY FINE AS WELL
WHAT'S ACTUALLY GOING ON IT'S BASICALLY ANY CHANCE IT GETS TO START CREATING A DIAGNOSTIC BECAUSE SOMETHING MIGHT BE GOING ON IN THE COMPILATION PROCESS IT WILL GO AHEAD AND DO IT
WHAT'S DIFFERENT ABOUT THE BROKEN CODE
WHAT'S GOING ON HERE
WHAT'S THE WORD I'M LOOKING FOR
WHATEVER ENDS UP IT DEPENDS ON WHAT KEEPS YOU MOTIVATED
WHEN ASYNC AWAIT ROLLED AROUND WE WERE NOT SURE ABOUT JUMPING ON THE BANDWAGON AND IN THE END WE DON'T USE IT
WHEN I ARRIVED TO MATRIX PEOPLE REALISED I DIDN'T DO ANYTHING AND SENT ME TO DO HOMEWORK BUT HELPED ME ANYWAY
WHEN I DID MY LITTLE PROJECT I BASICALLY STARTED OUT WITH DOING WORD COUNTING APPLICATION
WHEN I PROTOTYPE I OFTEN WRITE VERY MESSY CODE AND IT'S A BREATH OF FRESH AIR TO HAVE THE LANGUAGE GUARDING ME AGAINST STUPID MISTAKES
WHEN I STARTED THIS IN 2019 GITHUB WAS A PLACE TO SAFELY STORE AND DISTRIBUTE FILES
WHEN IN THE IR PHASE WHEN WE PARSE THE PHASE WE DISPOSE THE OBJECT AND THE ALLOCATUR TOGETHER
WHEN IT HAS BYTE CODE IN THE JVM RUST HAS MIR WHEN RUNNING MIRI
WHEN IT IS COMPILING IT SEES ERRORS THAT MIGHT NOT BE RELEVANT TO THE TASK AT HAND AND MIGHT CANCEL THOSE
WHEN MIRI'S ENGINE IS USED TO EXECUTE COMMS CODE DURING CALCULATION DOES IT RUN IN FAST MODE WITH LESS VALIDATION AND HOW DO I ASSESS THE DIFFERENCE
WHEN PURCHASED BY THE PLAYER THE ITEM DROPS FROM THE TOP AND THE PLAYER COLLECTS IT
WHEN READING GRAPHQL IT IS IMPOSSIBLE TO REFER TO DATA BECAUSE IT NEEDS TO GO THROUGH A PARSED STEP TO REMOVE THE ESCAPE CHARACTER
WHEN RIGHT NOW AGAIN THAT'S TAUGHT LATER IN THE CURRICULUM
WHEN RUST MODULE A CALLS SOME IMPORTED FUNCTION WHAT WE ARE GOING TO DO IS TO CALL AN EXPORTED FUNCTION FROM RUST MODULE B AND THIS WORKS BUT IT WORKS BUT THERE IS ANOTHER PROBLEM WITH IT
WHEN THE OBSTACLE IS MET THE SOUND WAVE WILL BOUNCE ON IT AND RETURN AS THE ECHO AND WE WILL MEASURE THE LENGTH OF IT
WHEN THE SOUND IS TRAVELLING 340 METRES IN ONE SECOND IT WILL BOUNCE ON AN OBSTACLE AND COME BACK SO WE NEED TO CALCULATE 34 000 DIVIDED BY 2 IN MILLISECONDS
WHEN WE FIND A PERFORMANCE BOTTLENECK WE THINK ABOUT HOW TO PRESS THAT ORCHESTRATION OR WHAT UNIT OF THAT ORCHESTRATION TO PRESS DOWN AND TRY TO FIND GOOD SORT OF BOUNDARIES MODULE BOUNDARIES ESSENTIALLY SO THAT WE CAN PRESS IT DOWN INTO RUST TO IMPROVE PERFORMANCE
WHEN WE KNOW THAT A VALUE IS SAFE WE CAN USE THE DECLASSIFY VERSION TO PUT IT BACK TO A PUBLIC VALUE
WHEN WE SUBTRACT ADJACENT BYTES X WAS SUBTRACTED FROM Y AND VICE VERSA
WHEN YOU CLICK ON THE RUN BUTTON THE CODE THAT YOU HAVE IN THE EDITOR IS SENT TO THE SERVER WHERE IT IS COMPILED BY THE RUST COMPILER AND THE MODEL IS PRODUCED AS A RESULT
WHEN YOU GO OUT AND DESIGN YOUR FORMATS CONSIDER DESIGNING WITH EFFICIENT NESTING IN MIND
WHEN YOU RUN THIS FOR EXAMPLE LET'S SAY THIS IS A CRATE IN THE RUST ECOSYSTEM USING CRATES IO AND SOMEONE ELSE DECIDES TO USE IT
WHEN YOU WANT TO RUN THE SAME CODE ON AN ARM PROCESSOR YOU HAVE TO REWRITE THE WHOLE CODE
WHEN YOU WRITE TESTS FOR CODE THAT FOR EXAMPLE SENDS NETWORK REQUESTS USUALLY WHAT YOU WANT TO DO IS TO MEANING YOUR CODE WON'T REALLY SEND REAL NETWORK REQUESTS BUT INSTEAD IT WILL PRETEND TO DO SO
WHENEVER WE CARGO BUILD THESE PACKAGES ARE FETCHED AND LINKED WITH THAT LIBRARY SO THE R PACKAGE CAN USE THEM
WHENEVER WE INSTALL CARGO EXPAND TOOL WE LOOK AT THE DASH AND THAT TOOL IS ENVOKED AND THE CARGO EXPAND TOOL IS AN AWESOME TOOL
WHENEVER WE RUN CARGO TEST THAT TEST IS RUN AND THE OUTPUT IS RECORDED
WHENEVER YOU RUN CARGO IT RUNS FROM THE TOOL INTERNALLY AND FIXES ALL OF YOUR CODE TO FOLLOW THE SAME GUIDELINE
WHEN�ASKED MY INSTRUCTORS WHAT THEY THOUGHT ABOUT IT MY PROFESSOR GAVE A VERY ENCOURAGING RESPONSE
WHERE
WHERE EACH BIT COMPROMISED PROVIDES INCREMENTAL VALUE AND THE CONFIDENTIAL SHALT OF COMPROMISE IS DESIRABLE
WHERE IT'S VERY STRAIGHTFORWARD RIGHT
WHERE MORE INFORMATION IS FOUND
WHERE THE PHILOSOPHY OF RUST IS JUST LIKE WE WANT MOST THINGS TO BE IN LIBRARIES
WHERE WE BASICALLY WORK TO LOBBY AND ADVOCATE FOR IMPROVING RUST'S ERROR HANDLING ECOSYSTEM
WHEREAS A LANGUAGE LIKE C PLUS PLUS WE GO TO THE C PLUS PLUS CORE GUIDELINES AND THE BEST THAT WE CAN GET FROM C PLUS PLUS TODAY IS THIS MAYBE
WHEREAS LAZINESS ON THE OPPOSITE END OF THE SPECTRUM WE'RE ONLY GOING TO DO A THING AT THE LAST MINUTE WHEN WE CAN NO LONGER GET AWAY WITH NOT DOING IT ANYMORE
WHETHER IT'S WITH CODE ARTS AND OR DOCUMENTATION FEEL FREE TO REACH OUT AND WE WOULD BE EXCITED TO MEET YOU
WHETHER THERE'S A SOLID COLOR OR A GRADIENT
WHICH AT LEAST ALLOWS YOU TO SEARCH BY KEYWORD AND SEE HOW THIS IS USED IN CONTEXT
WHICH BRINGS ME TO THE THIRD AND FOR ME AT LEAST THE MOST IMPORTANT IDEA IN LEARNING SOMETHING THAT IS
WHICH COLLECTIONS WOULD BE USEFUL
WHICH COULD BE A PROBLEM
WHICH FEATURES ARE THEY USING
WHICH GIVES A GREAT HABIT FOR STUDENTS AS THEY MOVE ON IN THEIR CAREER
WHICH GIVES YOU THE CONFIDENCE THAT YOU WILL NEED TO MOVE ON WITH YOUR PERSONAL PROJECT WITHOUT BEING SLIGHTLY OVERWHELMED ALL THE TIME
WHICH I THINK IS SORT OF A NEGATIVE IDEA AND I THINK WE SHOULD BE ABLE TO HAVE THE ABILITY TO REFACTOR OR PROGRAMS TO ADD NEW FEATURES OR TO IMPROVE THE PERFORMANCE
WHICH IN THIS GAME IS REPRESENTED BY BRIGHT GREEN SPACE ROCKS
WHICH IS
WHICH IS GREAT
WHICH IS TO SAY EVERY CHANCE WE GET TO GO AHEAD AND DO A THING WE'RE GOING TO DO IT
WHICH IS USUALLY A COUPLE OF MINUTES OR MAYBE AN HOUR IN DIFFERENT PROGRAMMING LANGUAGES
WHICH IS WHEN WE DISCUSSED PROJECT IDEAS THROUGH DIRECTOR MESSAGING
WHICH IS WHY THEY HAVE LABELS WITH ONE THROUGH FIVE
WHICH MAY BE A BIG DEAL IF YOU'RE REFACTORING YOUR PROJECT
WHICH MEANS THAT IF YOU CHOSE FOR YOUR PROJECT ALL THE FEATURES THAT YOU COULD POTENTIALLY WANT
WHICH MEANS THAT THERE'S GOT TO BE A LOT OF WORK DONE BEFORE WE HAVE THE ABILITY TO HAVE AN ANIMATION LIBRARY SUFFICIENT ENOUGH FOR THE COURSE
WHICH MEANS THAT YOU WILL BE PLUGGING THE CABLE FOR THE WHEELS IN THOSE TWO
WHICH MEANT IT CONTAINED MISTAKES THAT A PERSON NEW TO RUST WOULD MAKE
WHICH MOTIVATED ME TO CLEAN IT UP A BIT AND OPEN SOURCE IT
WHICH REGISTERS ARE SAVED IN STEP 1 OR STEP 3 ARE DETERMINED BY THE CALLING CONVENTION
WHICH TOOK A LOT OF TIME
WHICH UPLOADS THE SCENE AS A DATA STRUCTURE TO THE GPU
WHICH WAS NOT HARD TO LEARN WHICH AGAIN WAS MUCH TO LEARN
WHICH WAS QUITE NICE BECAUSE IT EXPLAINS A LOT
WHICH YOU MIGHT HEAR IT CALLED LIKE THE ERROR INDEX
WHILE DEDICATION ABOUT THE ARCHITECTURE AND CODE HAVE BEEN THE MAIN FOCUS CARLO HAS BEEN ACTIVELY WORKING TO PROVIDE CONTRIBUTION GUIDELINES AROUND ADDING NEW ITEMS TO THE GAME AS WELL AS ARTWORK
WHILE IN DOG WE CHECK TO SEE IF THE ANIMAL SHARED CONSTRUCTER RETURNED AN OKAY
WHILE IT WORKS ALMOST EXACTLY AS YOU SEE IT ON THE SLIDE SO WE HAVE AN STRUCT THAT HOLDS THE VARIABLE STATE AND LOCAL VARIABLES AND EACH BLOCK IS TRANSFORMED INTO A SEPARATE FUNCTION
WHILE THE OBVIOUS SOLUTION HERE IS TO COMPILE THESE DEPENDENCIES AS SEPARATE ASSEMBLY MODELS INSTEAD AND LINK THE DEPENDENCIES WHEN WE NEED THEM BUT THIS PROBLEM IS MADE WORSE BY THE FACT THAT THERE IS NO DYNAMIC LINKING STANDARD FOR THE WEBASSEMBLY
WHILE THESE DISCUSSIONS CAN BE DONE PRIVATELY INFORMATION THAT IS EASILY AVAILABLE WOULD ALLOW US TO REVISIT THE REASONING FOR WHY WE DECIDED TO MAKE CERTAIN IMPLEMENTATION DECISIONS
WHILE THIS IS A RECORDED TALK WE ARE CURRENTLY PRESENT AND READY TO ANSWER QUESTIONS
WHILE THREADS ARE DEFINITELY INTRODUCED IN A LATER COURSE
WHILE WE GAIN DATA INDEPENDENCE WE LOSE THE ABILITY TO USE COMPRESSION TECHNIQUES THAT WOULD RELY ON VARIABLE LENGTH AND CODING
WHILE WE'RE USING F THIRTY TWO FOR DOUBLES
WHO IS STOPPING ME
WHO MAYBE DO NOT IDENTIFY AS EXPERTS
WHY AREN'T THESE LANGUAGE LEVEL PROTECTIONS GOOD ENOUGH
WHY DO WE DO THAT
WHY DO WE HAVE TO WORK WITH NO STD WHICH IS RUST NON STANDARD CODE
WHY DO YOU FEEL IT'S HARD
WHY DON'T WE JUST IF WE CAN'T WRITE SECURE CODE WHY DO WE WANT TO USE RUST IN THE FIRST PLACE
WHY DON'T WE TRY INCLUDING ALL THE NECESSARY DEPENDENCIES RIGHT THERE ON THE SAME PAGE SO THAT A USER CAN IMMEDIATELY RUN THIS CODE AND SEE THE RESULTS
WHY SHIELD THEM FROM THE COMPLICATIONS AND NOT UNDERSTAND THE DIFFERENCE BETWEEN STACK AND KEY FOR EXAMPLE
WILL YOU BOTH BE ACTIVE IN THE CHAT TO HELP AROUND
WITH A PREDICTION ALGORITHM IN HAND WE NEED TO COME UP WITH A REPRESENTATION
WITH ASYNCHRONOUS CODE THIS APPROACH CAN REALLY MAKE A DIFFERENCE IN UNDERSTANDING HOW IT WORKS
WITH JSON THE INTERPRETATION OF EVERY SINGLE BITE IN THE DATA DEPENDS ON EVERY PROCEEDING BITE
WITH LIST THIS IS EASY TO DEMONSTRATE
WITH RUST OF COURSE ALL OF THIS GOES AWAY
WITH RUST YOU HAVE TO COMPILE AND THEN YOU CAN RUN THE UNIT TESTS AND I MEAN IT'S NOT A BIG THING BUT IT IS A THING
WITH RUST YOU'LL GO FAR
WITH THAT YOU GET THE BEST PERFORMANCE POSSIBLE BY AVOIDING ALLOCATIONS AND COPIES BUT YOU LOOSE OUT ON THE ABILITY TO MANIPULATE THE DATA
WITH THE ENGINEERING RUST TOOLING THE SEMANTIC LANGUAGE HERE WE MENTIONED HERE BUT YOU CAN FIND MORE ON THE OPEN SOURCE REPO
WITH THIS DESIGN CHOICE ANY QUOTES IN THE STRING MUST BE ESCAPED WHICH INSERTS NEW DATA INTERPURSED WITH THE ORIGINAL DATA AND THIS COMES WITH CONSEQUENCES
WITH THIS SAFE AND CONVENIENT TYPE ENABLED BY OUR FRIEND AND ALLIED THE BORROW CHECKER WE CAN PARSE THE GRAPHQL IN SUCH A WAY THAT ALL OF THE TEXT EFFICIENTLY REFERS TO THE SOURCE EXCEPT JUST THE PARTS THAT YOU MANIPULATE AND IT IS ALL SPECIFIED AT THE CALL SITE
WITH TIME YOU WILL NOTICE THAT ALL COMPONENTS ARE STANDARD AND PRETTY MUCH THE SAME BUT THE EASIEST WAY TO GET STARTED IS JUST TO BUY A KIT
WITH WEBASSEMBLY ENABLED PLAYGROUND WE JUST NEED TO PROVIDE OUR OWN LOGIN LIBRARY THAT WILL REDIRECT OUTPUT FROM THE LOGS TO A USER'S BROWSER
WITH WEBASSEMBLY WE HAVE A REALLY GOOD CHANCE OF BRINGING THIS SIMPLICITY INTO THE RUST WORLD
WITH WHATEVER WE'RE DOING IMMEDIATELY WE WANT TO RESTORE THAT ETCH A SKETCH TO ITS PREVIOUS STATE
WITHIN THE RUST COMPILER WITHIN A LIBRARY USED BY RUST CALLED LLVM
WITHOUT CARGO YOU DON'T REALLY HAVE ANYTHING ELSE THAT YOU CAN USE THAT STUDENTS WOULD BE ABLE TO PICK UP QUICKLY
WITHOUT FURTHER ADO LET'S START WITH INTRODUCTIONS
WITHOUT SEEING THE DIFFERENCE IT IS HARD TO APPRECIATE THE POWER THAT RUST HAS OVER DATA
WONDERFUL
WORKING MESSAGES AROUND A DESKTOP APPLICATION
WORKING ON SPACE SHOOTER IS A PROJECT THAT AIMS TO BE A FUN AND INFORMATIVE LEARNING EXPERIENCE
WORKSPACE ALLOWS YOU TO GROUP MULTIPLE PACKAGES
WOULD HELP TO POSE THIS QUESTION FOR ME SPECIFICALLY WITH
WOULD I WANT TO USE
WOULD IT BE POSSIBLE TO DO THIS KIND OF ANALYSIS GENERAL LLVM IR
WOULD YOU MIND GOING BACK A COUPLE OF SLIDES BECAUSE WE LOST YOU QUITE SOME TIME AGO
WOW
WOW NO
WRITE IN THE SAME SERVER
WRITING A TREE BUF FILE IS ONE STEP
WRITING CRYPTOGRAPHIC IN HIGH LEVEL LANGUAGES LIKE RUST IS ATTRACTIVE FOR NUMEROUS REASONS
WRITING RUST TO MOVE
WRITING THE DELTAS AND CRAFTING INTS WAS ONLY POSSIBLE BECAUSE WE KNEW THE BYTES WERE UAS AND NOT STRINGS WHERE SUBTRACTING JSON CHARACTERS PRODUCES NONSENSE
YEAH
YEAH FOR SURE WE HAVE A LOT OF GOOD DOCUMENTS ONLINE
YEAH GLAD TO
YEAH I WOULD MOST LIKELY DO A COPY WHERE I WOULDN'T REALLY WANT A COPY
YEAH IT IS COVERING I WOULD SAY A LOT OF AREAS AND VARIOUS TOPICS
YEAH NO NO WORRIES ABOUT THAT
YEAH SURE
YEAH THANK YOU FOR SUCH A DEEP PRESENTATION
YEAH THAT REALLY IS THE FOCUS OF THE TALK
YEAH WE CHANGED THE RESULT TYPE TO BE A RESULT WHERE THE OKAY IS AN ANIMAL SHARED OBJECT WHILE THE ERROR IS THE STRING FOR THE ANIMAL SHARED CONSTRUCTER
YEP
YEP SEE YA
YES
YES ACTUALLY LET ME
YES I HAVEN'T HAD TIME TO UPDATE THAT YET AND THIS WAS WRITTEN ON FIVE SO WE WILL SEE IF IT WORKS WITH SIX AND SEE IF THERE IS ANYTHING THAT NEEDS CHANGED
YES I WILL STAY HERE
YES I'VE DEFINITELY PLAYED AROUND A BIT WITH THE PY O3 PROJECT THE PY OXIDE PROJECT
YES IF YOU CAN USE THE PARSER COMING OUT OF THE RTC FOR PC6 AND WHAT THE
YES IT HAS BEEN RELEASED
YES IT IS REALLY IN THE 10 POSITION FOR THE 11TH IF YOU WANT TO THINK IN ZERO IN ZERO BASED INDEXES
YES IT'S HARDER BUT I BELIEVE IT'S POSSIBLE TO DO THAT
YES OKAY SO WHAT I REALLY WANTED TO VON WAY WITH THIS TALK WAS THAT IT IS NOT THAT HARD
YES SO WHAT WE ARE AIMING TO DO IS HAVE THESE RUN THROUGH A SINGLE PROTOCOL SPECIFIED IN A DRAFT
YES THANK YOU SO MUCH FOR THE TALK
YES THAT'S THE DEMO
YES THE QUESTION SO THE 11TH ELEMENT IN THE SAID ABOUT RECEIVING ALLOCATION THAT WAS FREED IT WAS OUT OF BOUNDS SO I GUESS THIS IS THE QUESTION
YES THE WAY WE DISCOVER THESE KINDS OF ISSUES IS LIKE AT SOME POINT SOMETIMES WRITE A PIECE OF ASSEMBLY
YES THIS IS NOT CLEAR FOR ME ACTUALLY
YES TO CATCH THE SUBTLE BUGS WHICH OKAY YOU KNOW ESSENTIALLY WHAT OUR PARSERS ARE TESTING IS YOUR OUTPUT ON THE WIRE CORRECT DOING WHAT YOU THINK IT'S DOING
YES WE CAN USE THIS FOR ALL SORTS OF DIFFERENT PATROLS COLES
YES YOU'RE WELCOME
YOU ALWAYS BUILD A RELEASE MODE OR IS THERE SPEED UP AND DEBUG MODE ALSO GOOD ENOUGH
YOU CAN
YOU CAN ALSO DO THINGS LIKE GUIDED GENERATIONS STYLE TRANSFER FILL IN MISSING CONTENT AND SIMPLE GEOMETRY GENERATION
YOU CAN ASK ANY QUESTION ON THE COMMUNITY FORUM
YOU CAN ASK ME ANY QUESTION YOU LIKE
YOU CAN ASK ME HOW IS MY GRID ABLE TO OFFER TWO VARIANTS
YOU CAN DE REFERENCE RAW POINTERS YOU CAN CALL FUNCTIONS THAT ARE MARKED AS UNSAFE
YOU CAN DO A LOT OF MESSY STUFF WITH THEM
YOU CAN DO ONLY FIVE THINGS NOT ANY MORE
YOU CAN DO THIS BY RUNNING THE RUSTUP TOOLCHAIN INSTALL NIGHTLY
YOU CAN FIND ALL THE CODE IN GITHUB COM RUST LANG MIRI
YOU CAN FIND THE REPOSITORY AT THE ADDRESS YOU SEE ON THE SLIDE SO IF YOU'RE INTERESTED YOU CAN JOIN THE DEVELOPMENT EFFORT AND HELP TO MAKE THIS A REALITY
YOU CAN GET A LOT MORE COMPUTATION DONE BOTH PER SECOND AND PER WATT WITH A GPU THAN A CONSUMER SINGLE CPU CORE
YOU CAN GET AROUND LIFETIMES YOU CAN GET AROUND REFERENCE PASSING
YOU CAN GO AHEAD AND LIKE TAKE THIS ERROR CODE IF RUST C GIVES IT TO YOU
YOU CAN HAVE NULL POINTERS THAT DON'T POINT TO ANYTHING REALLY
YOU CAN HAVE THE RAW POINTER TO IT EVEN THOUGH IT IS POINTING TO SOMETHING THAT DOESN'T EVEN EXIST ANY MORE
YOU CAN IN FACT WE DO NOT NEED TO REJECT AND SAVE
YOU CAN INTEGRATE RUST INTO PYTHON JUST BY EXPOSING IT AS SORT OF A PYTHON MODULE
YOU CAN KNOW WHERE ANY ARBITRARY PIECE OF DATA LIVES AND BREAK IT UP INTO ANY DESIRED SIZE
YOU CAN MINUTE DIRECTORIES DELETE FILES CREATE SYMBOLIC LINKS YOU CAN SPAWN THREADS USING LOCKS AND ATOMICS YOU CAN USE IT TO GET THE CURRENT TIME SO RUN CLOCKS INSIDE YOUR PROGRAM
YOU CAN NOTICE THE SAMPLING MASK IS GENERATED BASED ON EDGES AND EDGES PLAY A VERY IMPORTANT ROLE IN DRAWING
YOU CAN OPEN UP YOU CAN CONTACT THE CONTRIBUTORS TO DISCUSS IT OR FROM THE UNSAFE WORKING GROUP ALSO
YOU CAN RUN LIKE LET'S SAY UNDISRUPTED CONSTANT EVALUATION AND MOST OF THE TIME IT BREAKS THE COMPILER BUT YES YOU CAN ACTUALLY RUN WHATEVER YOU WANT
YOU CAN RUN YOUR WHOLE PROGRAM IF YOU WANT WITH MIRI OR YOU CAN RUN JUST YOUR TEST SUITE IF YOU HAVE TESTS
YOU CAN SAY TO YOURSELF WHAT A LOT OTHERS MANY MANY HEADS DEBUGGING AND HOW THE DIFFERENT BEHAVIOUR WORKS
YOU CAN SEE HERE
YOU CAN SEE HERE ON THIS BOARD
YOU CAN SEE HERE THAT I JUST FOLLOW THE DOCUMENTATION
YOU CAN SEE HOW EARLIER SKETCHES WERE IN A DIFFERENT STYLE THAN THE FINAL WORK
YOU CAN SEE HOW THE HIR CAN GET TRANSFORMED FROM THE TOP CIRCLE QUERY
YOU CAN SEE IT LATER
YOU CAN SEE MORE INFORMATION AND SO ON
YOU CAN SEE ON THIS DIAGRAM ANYTHING THAT'S NOT A PIXEL INTERSECTED BY THE CURVE DOESN'T HAVE TO BE PROCESSED ON THE CPU AND GETS FILLED IN BY THE GPU WHICH IS GOOD AT DOING KIND OF SIMPLE HIGHLY PARALLEL TASKS LIKE FILLING IN A BUNCH OF SOLID PIXELS
YOU CAN THINK OF A SEARCH PROCESS IN A SIMPLIFIED WAY THAT IS WE TRY A BUNCH OF CONFIGURATIONS WE PRESENT YOU WITH THE MOST PROMISING ONE
YOU CAN THINK OF THIS TYPE LIKE A SLIDE OR IF YOU WANT LIKE A VECTOR BUT WE ARE WE ONLY HAVE TWO SIMPLE FUNCTIONS
YOU CAN USE CARGO TO ESSENTIALLY RUN EXTERNAL BINARY TOOLS
YOU CAN USE PHENOTYPE OPENING BENEATH YOUR ONE TO ZERO PLATFORM
YOU CAN USE THE LOG LEVELS AND EMIT EVENTS IN YOUR LIBRARIES OR BINARIES ESSENTIALLY
YOU CAN USE THE NIGHTLY FOR THE FUTURE LIKE PROC MACRO DIAGNOSTIC FOR DEBUGGING WHICH IS IMPORTANT
YOU CAN USE THE SETLOGGER FUNCTION TO SET THE LOGGER
YOU CAN USE UNSAFE TO ACCESS FIELDS OF UNIONS
YOU CAN'T INTERPRET THAT
YOU CAN'T PLACE A STONE ON TOP OF A PREVIOUSLY PLAYED STONE
YOU CAN'T TELL FROM THE PICTURE WHAT THE COMPUTER IS DOING IF IT IS DOING ANYTHING AT ALL
YOU CANNOT CHECK THE TYPE OF AN OBJECT
YOU COULD HARD CODE THESE BUT THE COMMENT EXPLAINING WHAT THE MAGIC NUMBERS WERE WOULD BE JUST AS LONG AS THE CODE ANY WAY SO IT MIGHT AS WELL BE CODE SINCE THAT MAKES IT MORE LIKELY TO BE CORRECT AND IN SYNC WITH THE REST OF THE FUNCTION
YOU COULD USE THE RUSTC CLI BUT THAT HAS A LOT OF EXTRA STUFF IN AND IT ULTIMATELY IS TOO COMPLICATED FOR STUDENTS TO LEARN HOW TO PICK UP
YOU COULD WRITE A DETERMINISTIC GO AI AND HAVE IT SORT PREDICTION FROM BEST TO WORSE AND PREDICT IT IS MORE LIKELY THE PLAYER WILL MAKE A GOOD MOVE VERSUS A BAD ONE
YOU CREATE A SMALL SCREEN LIKE A DIALOGUE AND KITTIS TRIES TO MINIMISE THE WAY YOU CREATE BY ANALYSING HOW YOU PLACE THINGS AND USING IT AS AN EXAMPLE
YOU CREATED A POINTER THAT IS OUTSIDE THE ACTUAL RANGE OF THE VECTORS SO WHEN THE VECTOR GETS DELETED BECAUSE IT IS DELETED AFTER EVERYONE HAS USED IT YOU STILL HAVE THIS POINTER POINTING TO NOTHING
YOU DIDN'T PUT ANGLE BRACKETS IN I'M GOING TO GO AHEAD AND SUGGEST THAT YOU PUT THOSE IN
YOU DO HAVE ACCESS TO THE CORE LIBRARY
YOU DO NOT NEED TO DO THAT
YOU DO NOT NEED TO PAY ATTENTION TO ALL THOSE DETAILS
YOU DON'T HAVE TO CHANGE A LOT
YOU DON'T HAVE TO GIVE ANYONE COVERAGE FOR THIS
YOU DON'T HAVE TO GO THROUGH ALL OF THAT MENTAL ALGORITHM TO GO AHEAD AND DECIPHER WHAT THAT ERROR MESSAGE IS SAYING
YOU DON'T NECESSARILY NEED TO DO PATTERN MATCHING OR COMPLEX PROGRAMS OR NICE PATCHING IF YOU CAN JUST GO FOR REFILLS
YOU DON'T NEED ANY COMPLICATED SET UP
YOU DON'T NEED TO CONFIGURE IT INTO INPUT BECAUSE THEY'RE ALL INPUT BY DEFAULT AND THEN YOU DON'T NEED TO HAVE IT MUTABLE BECAUSE WE ARE JUST GOING TO MONITOR HOW LONG IT IS HIGH
YOU DON'T NEED TO KNOW WHICH SPECIAL FLAGS TO PASS TO YOUR COMPILER
YOU DON'T OVERBURDEN YOURSELF AND YOU MAKE SLOW PROGRESS
YOU DON'T REALLY LEARN THE IDEAS OF STACK AND HEAP UNTIL COMPUTER SYSTEMS THE COURSE THAT I WAS TALKING ABOUT
YOU DON'T REALLY WANT TO TRUST ONE POINT NUMBERS THIS IS GOT SOMETHING ELSE
YOU GET A LOT WITH MINIMUM EFFORT USING SOMETHING LIKE GZIP
YOU GET PROTOCOLS THAT ARE BECOMING INCREASINGLY MORE COMPLEX LIKE QUIC
YOU HAD TO WATCH YOUR OWN TALK
YOU HAVE ISSUES WITH THE LINTER MAKING SURE PEOPLE CHECK THEIR ERROR RETURNS
YOU HAVE LEARNED SOMETHING YOU'RE MOTIVATED TO LEARN SOMETHING MORE WRITE SOME CODE LOOK AT THE CODE
YOU HAVE MUCH LESS MEMORY IN MOST EMBEDDED DEVICES
YOU HAVE THE ERROR CODE
YOU HAVE THE TELL ANIMAL TO SPEAK FUNCTION WHICH DYNAMICALLY DISPATCHES ON AN ANIMAL REFERENCE
YOU HAVE TO
YOU HAVE TO DESIGN THE REPRESENTATION DIFFERENTLY TO OVERCOME THIS
YOU HAVE TO DO A HYBRID APPROACH WITH STEREOTYPES AND MAYBE RENDERING THE BIGGER SHAPES ON THE GPU
YOU HAVE TO DO AN UNSAFE BLOCK OR FUNCTION
YOU HAVE TO FIGURE OUT HOW YOU'RE GOING TO MAKE YOUR APPLICATION USE DIFFERENT APIS ON DIFFERENT PLATFORMS IF DO WANT TO BE CROSS PLATFORM
YOU HAVE TO HAVE HELP AND IF YOU HAVE THE RIGHT HELP IT'S NOT THAT DIFFICULT AND THE MOST DIFFICULT IS REALLY DO YOU I START WITH IT
YOU HAVE TO INSTALL THE NIGHTLY TOOLCHAIN
YOU HAVE TO SHOW ME
YOU HAVE TO WONDER IS IT JUST HARD TO LEARN
YOU JUST HAVE TO DO RUSTUP COMPONENT ADD MIRI
YOU JUST PUT IN CODE OR DECODE ATTRIBUTES ON YOUR STRUCTS AND CALL THE DATA
YOU KIND OF HAVE TO LOOK AT THIS AND TRY TO FIGURE OUT WHAT THE INTERPRETER IS TELLING YOU
YOU KNOW
YOU KNOW IT'S NOT ENOUGH JUST TO DEFINE WHAT HAS TO HAPPEN
YOU KNOW MAYBE YOUR CODE DOESN'T HAVE A DATA RACE
YOU KNOW THERE WERE MANAGEMENT ISSUES OR YOU KNOW PROJECT OVERSIGHT ISSUES
YOU MAY END UP WITH SCREENS ON SCREENS OF NOT NICE IF ELSE STATEMENTS BUT THEN YOU CAN END UP WITH A PROGRAM THAT YOU CAN REFACTOR
YOU MAY HAVE DIVIDED YOUR LIBRARY INTO MULTIPLIES AS IT GROWS AND GETS BETTER
YOU MAY HAVE HEARD IN TEXTBOOK THAT WHAT KIND OF MODEL IT IS OPERATING MODEL WHICH IS LOW AND INEFFICIENT WHICH IN TENSORBASE SO WE DON'T USE OPERATOR LEVEL VOLCANO
YOU MAY SAY IN THE TRADITIONAL TEXTBOOKS RELATIONAL ALGEBRA OPERATORS BUT HERE WE JUST UNIFIED INTO FOUR OPERATORS
YOU MIGHT ALSO NOTICE THAT THE SPACESHIP ENEMY AND ITEM ENTITIES HAVE A COMPONENT WITH THEIR SAME NAME
YOU MIGHT BE ATTEMPTED TO DO SOMETHING LIKE CAN I READ THE 11TH PRECISION OF AN ARRAY WITH TEN ELEMENTS
YOU MIGHT BE WONDERING WHAT IS A PROCEDURAL ARTIST
YOU MIGHT BE WONDERING WHY DOES THIS MATTER
YOU MIGHT HAVE A VIDEO PERIPHERAL ALTHOUGH IT'S SOMEWHAT RARE
YOU MIGHT HAVE ANSWERS IF YOU'RE USING IT WRONG YOU'RE CAUSING UNDEFINED BEHAVIOUR OR UNDEFINED BEHAVIOUR IS SUPER BAD
YOU MUST BE CAREFUL TO FOLLOW THEM AND YOU MUST PLUG THEM AS THEY LOOK ON THE IMAGE BUT THE MOST IMPORTANT IS TO MAKE SURE THAT THE CIRCUIT IS GROUNDED THAT MEANS THAT ALL GROUND CABLES ARE CONNECTED THAT THE CIRCUIT HAS A COMMON GROUND
YOU MUST WRITE PROGRAM TO FIT IN 512 BYTES
YOU NEED EXAMPLE CODE TO MAKE IT WORK
YOU NEED THE VERSION OF THE FIRE TO DO THIS
YOU NEED TO INTERACT WITH OTHER LANGUAGES OR WITH YOUR OPERATING SYSTEM OR WITH A BUNCH OF RESOURCES THAT AREN'T BRIAN THEMSELVES IN RUST
YOU NEED TO KNOW HOW MIRI WORKS COMPLETELY TO DO THAT
YOU NEED TO KNOW WHERE TO FIND HELP
YOU NEED TO SET UP A NEW RUST PROJECT AND THEN ADD DEPENDENCIES THROUGH CARGO
YOU NEED TO VIEW SLICES OF STRINGS AND BYTE ARRAYS SAFELY AND WITHOUT COPYING
YOU NOTICE THAT IT IS PRESCALED WITH A FACTOR OF 1 024 AND THE PIN IS D3 AND THEN WE ENABLE IT
YOU REALLY ONLY HAVE TO ACT ON THE RESULTS TYPE WHICH YOU CAN USE BY CHECKING WHETHER OR NOT IT'S OKAY OR AN ERROR
YOU REPLACE THE LOG TRACE WITH THE TRACING AND EVERYTHING SHOULD WORK
YOU SAID THAT YOU GAVE US AN INSIGHT YOU GO WITH WHAT THE COMPILER SAYS FIRST AND THEN YOU CAN DISCOVER IT
YOU SEE THIS IN LOTS OF OTHER LANGUAGES AS WELL
YOU SHOULD BE ABLE TO HEAR ME NOW
YOU SHOULD JOIN THE AMETHYST DISCORD
YOU TEND TO HAVE ACCESS TO PERIPHERALS THAT ARE MUCH MORE LIMITED
YOU THE NEXT ITEM ON MY LIST HERE IS A VECTOR TEXTURES ARCHITECTURE
YOU THINK THIS PROGRAM IS CORRECT AND COMPLAINING
YOU WILL SEE HERE WE HAVE MAX SCREEN WHICH IS THE DATA PARTITION LOCATION
YOU WILL USE THE RUST DEFAULT COMMAND TO MAKE THAT AS THE DEFAULT
YOU WIN IT BACK VERY QUICKLY BECAUSE SEEKING OUT THOSE BUGS DOMINATES IN TERMS OF TIME SO THAT UPFRONT LEARNING COST IS NOTHING COMPARED TO THE COST OF SOME HORRIBLE SEG FAULT THAT YOU CAN'T FIND
YOU WON'T NEED TO FIGHT
YOU WOULD BE ABLE TO STICK SOMETHING LARGE IN THERE IF YOU WOULD LIKE
YOU WOULD HAVE TO ADD A LOT OF METADATA BECAUSE NEW TYPES MAYBE CONSCIOUS IN
YOU'LL NOTICE PATHFINDER ALSO APPEARS HERE BECAUSE PATRICK WALTON IN RECENT MONTHS DEVELOPED ANOTHER RENDERER FOR PATHFINDER THAT USES GPU COMMUNITY
YOU'RE GENERALLY RUNNING THE RUST COMPILER ON THE SAME DEVICE THAT THE PROGRAM YOU'RE COMPILING RUNS ON
YOU'RE NOT ONLY KNOW OKAY I HAVE SEEN IN THIS BOOK THAT I NEED TO DO THIS IN THE FOLLOWING WAY AND KNOW THE ROUGH CONCEPTS
YOU'RE THINKING OF THE STACK AS SORT OF NESTED CONTEXT FOR THE PROGRAM
YOUR APP IS PRESUMABLY NOT JUST A UI
YOUR CODING FEET WET
YOUR COMPUTER BY ITSELF DOESN'T DO ANYTHING OF VALUE
YOUR DATABASE IS JUST A GIANT SERIALIZED FILE AFTERALL AS ARE THE REQUESTS FOR THE DATA IN THE DATABASE
YOUR PROGRAM MIGHT HAVE UNDEFINED BEHAVIOUR IF YOU'RE REFERENCING POINTER THAT IS DANGLING UNALIGNED
YOUR RUST PROGRAM RUNNING MIRI YOU CAN HANDLE ENVIRONMENTAL VARIABLES AND EACH OF THOSE OPERATIONS IS POSSIBLE SOMEONE DECIDED TO WRITE AN SHIM FOR THAT SPECIFIC FOREIGN FUNCTION
YOUR SERIALIZATION IS MUCH DEEPER TO BE HONEST AND I UNDERSTAND NOW
ZAC BURNS WANTS TO SERIALIZE

schenrfg.md

DeepSpeech for RustFest / Waasabi

This is Mozilla DeepSpeech v0.9.3 running inference using the out-of-the-box pre-trained English model on a one-minute excerpt of Sean Chen's talk from RustFest Global 2020.

Rust's error messages are one of the... I suppose one of its killer features.

rameses and one of the i suppose one of its killer features

Even though sometimes I also think they're a little bit...

even though sometimes i also think there are a little bit

what's the word I'm looking for?

that i looking for

They're not given as much credit as... as usual.

there is not given as much credit as as you see

They're just not in the limelight as much, I suppose.

but there is not in the limelight as much i suppose

And if I had to go ahead and kind of rank different programming languages kind of on a tier list of the quality of their error messages,

and if i had to go ahead and kind of rank different programming languages kind of on a tearless of the quality of their armitage

I would probably go ahead and do it something like this where I would put Rust in S tier.

i probably go ahead and do it something like this where i would put rust in astern

And I think kind of the only other language that I would also say is kind of in the same class would be Elm.

i think kind of the only other language that i would also say it's kind of in the same class would be emotional

Because I know Elm also... the community there also cares a lot about having their error messages be really helpful and unintimidating.

the community there also cares a lot about having the air messages be really helpful and unintimidating

And then kind of everything else going down. Something like this.

and then kind of everything else going down something like this

By the way, this is just my opinion.

by the way this is just my opinion