We're changing the culture of tech through our in-person and live-online bootcamps for women, trans, and non-binary people (women+). We're headquartered in Barcelona and our students and graduate network span 70+ countries. We believe education gives birth to new worlds and helps old worlds disappear: marginalisation, gender disparity, underrepresentation, biases— issues all too commonplace in an industry that aspires to uplift us all. We're here to provide the safe space, training, and resources needed to encourage, support, and equip women+ with the skills they need to thrive in the tech industry. In doing so, we aim to change the culture of tech worldwide. CodeOp was founded in 2018 to help solve the gender disparity problem in the tech space. We're the first international tech school for women+ who want to transition to, or upskill in tech.

CodeOp

codeop

Another year is drawing to an end, and it's a perfect time to make yourself a cup of coffee and reread the reviews of bugs collected across open-source projects over this year. This would take quite a while, of course, so we prepared this article to make it easier for you. Today we'll be recalling the most interesting dark spots that we came across in open-source C/C++ projects in 2019. No. 10. What Operating System Are We running On? Possible typo in the spelling of a pre-defined macro name. The '__MINGW32_' macro is similar to '__MINGW32__'. winapi.h 4112 V1040 There is a typo in the name of the _ macro (MINGW32 is actually declared by __MINGW32__). Elsewhere in the project, the check is written correctly: __MINGW32 By the way, this bug was not only the first to be described in the article " " but the very first genuine bug found by the V1040 diagnostic in a real open-source project (August 19, 2019). CMake: the Case when the Project's Quality is Unforgivable No. 9. Who's First? Perhaps the '?:' operator works in a different way than it was expected. The '?:' operator has a lower priority than the '==' operator. mir_parser.cpp 884 V502 We are interested in the following part: The precedence of the '==' operator is higher than that of the ternary operator (?:). Therefore, the conditional expression is evaluated in the wrong order and is equivalent to the following code: Since the constants and are non-null, the condition will be returning all the time, which means the body of the branch is unreachable code. OP_intrinsiccall OP_intrinsiccallassigned true else This bug was described in the article " ". Checking the Ark Compiler Recently Made Open-Source by Huawei No. 8. Dangerous Bitwise Operations Unsafe usage of the bool' and 'int' types together in the operation '&='. GSLMultiRootFinder.h 175 V1046 The code suggests that the function traverses an iterator list. If at least one iterator is invalid, the function returns , or otherwise. SetFunctionList false true However, the function can return even for valid iterators. Let's figure out why. The function returns the number of valid iterators on the list. That is, adding non-null iterators will cause the list to incrementally grow in size: 1, 2, 3, 4, and so on. This is where the bug comes into play: SetFunctionList false AddFunction fFunctions Since the function returns a value of type rather than , the '&=' operation will return for even values because the least significant bit of an even number is always set to zero. This is how one subtle bug can break the return value of even when its arguments are valid. int bool false SetFunctionsList If you were reading the snippet carefully (and you were, weren't you?), you could have noticed that it came from the project ROOT. Yes, we checked it too: " ". Analyzing the Code of ROOT, Scientific Data Analysis Framework No. 7. Variables Mixed Up [CWE-563] The 'Mode' variable is assigned but is not used by the end of the function. SIModeRegister.cpp 48 V1001 It's very dangerous to use the same names for function arguments as for class members because you risk mixing them up. And that's exactly what happened here. The following expression doesn't make sense: The function's argument changes, and that's it. This argument is not used in any way after that. What the programmer really wanted to write was probably the following: This bug was found in . We have a tradition to check this project every now and then. This year we it one more time. LLVM checked No. 6. C++ Has Its Own Laws This bug stems from the fact that C++ rules don't always follow mathematical rules or "common sense". Look at the small snippet below and try to find the bug yourself. Suspicious comparison found: 'f0 == f1 == m_fractureBodies.size()'. Remember that 'a == b == c' is not equal to 'a == b && b == c'. btFractureDynamicsWorld.cpp 483 V709 The condition seems to be checking that is equal to and is equal to the number of elements in . It was probably meant to check if and are located at the end of the array since they contain an object position found by the method. But in reality, this conditional expression checks if is equal to and then if is equal to the result of the expression . That is, the third operand here is checked against 0 or 1. f0 f1 m_fractureBodies f0 f1 m_fractureBodies findLinearSearch() f0 f1 m_fractureBodies.size() f0 == f1 That's a nice bug! And, fortunately, a pretty rare one. So far we have it only in three open-source projects, and, interestingly, all the three were game engines. This is not the only bug found in Bullet; the most interesting ones were described in the article " ". seen PVS-Studio Looked into the Red Dead Redemption's Bullet Engine No. 5. What's At The End Of The Line? This one is easy if you know one tricky detail. EOF should not be compared with a value of the 'char' type. The 'ch' should be of the 'int' type. json.cpp 762 V739 This is one of those bugs that you can't easily spot if you don't know that is defined as -1. So, if you try to compare it with a variable of type , the condition will almost always be . The only exception is the character encoded as 0xFF (255). When compared with , this character will turn into -1, thus making the condition true. EOF signed char false EOF A lot of bugs in this years Top 10 were found in computer gaming software: engines or open-source games. As you already guessed, this one came from that area too. More errors are described in the article " ". Cataclysm Dark Days Ahead: Static Analysis and Roguelike Games No. 4. The Magic Constant Pi There is probably a misprint in '3.141592538' constant. Consider using the M_PI constant from <math.h>. PhysicsClientC_API.cpp 4109 V624 There's a tiny typo in the Pi number (3,141592653...): the number "6" is missing at the 7th decimal place. An incorrect one-millionth decimal digit would hardly cause any noticeable harm, but it's still better to use existing constants from libraries, whose correctness is guaranteed. The Pi number, for instance, is represented by the constant M_PI from the header math.h. You already read about this bug in the article " ", where it was placed sixth. If you haven't read it yet, this is your last chance. PVS-Studio Looked into the Red Dead Redemption's Bullet Engine A Small Diversion We are approaching the Top 3 most interesting bugs. As you have probably noticed, I'm sorting the bugs not by their impact but by the effort it takes a human reviewer to find them. After all, the advantage of static analysis over code reviews is basically the inability of software tools to get tired or forget things. :) Now, let's see what we have in our Top 3. No. 3. An Elusive Exception Classes should always be derived from std::exception (and alike) as 'public' (no keyword was specified, so compiler defaults it to 'private'). CalcManager CalcException.h 4 V702 The analyzer has detected a class derived from the class using the modifier (which is used by default if not specified otherwise). The problem with this code is that an attempt to catch a generic will cause the program to miss an exception of type . This behavior stems from the fact that private inheritance forbids implicit type conversion. std::exception private std::exception CalcException You definitely wouldn't like to see your program crash because of a missed modifier. By the way, I bet you have used this application at least once in your life because it's the good old , which we also earlier this year. public Windows Calculator checked No. 2. Unclosed HTML Tags Possibly an incorrect HTML. The "</body>" closing tag was encountered, while the "</div>" tag was expected. book.cpp 127 V735 As it often happens, C/C++ source code doesn't say much by itself, so let's take a look at the preprocessed code generated from the snippet above: The analyzer has found an unclosed tag. There are many html-code fragments here, so the authors need to revise it. <div> Surprised we can diagnose this kind of bugs? I was impressed too when I saw that for the first time. So, yes, we do know something about analyzing html code. Well, only if it's within C++ code. :) Not only is this bug placed second but it's a second calculator on our Top 10 list. To learn what other bugs we found in this project, see the article " ". Following in the Footsteps of Calculators: SpeedCrunch No. 1. Elusive Standard Functions Here's the bug that placed first. This one is an impressively weird bug, which managed to make it through the code review. Try to find it yourself: Now let's see what the analyzer has to say: A part of conditional expression is always true: ('\n' != c). params.c 136. V560 Weird, isn't it? Let's take a look at some other curious spot but in a different file (charset.h): Hm, this is strange indeed... So, if the variable is equal to then the seemingly harmless function will return , thus preventing the second part of the check from executing due to short-circuit evaluation. And if executes, the variable will be equal either to or which is obviously not being equal to . c '\n', isspace(c) false isspace(c) c ' ' '\t', '\n' You could argue that this macro is similar to and code like that would never make it through a code review. But this particular snippet did – and was sitting in the repository waiting to be discovered. #define true false For more detailed commentary on this bug, see the article " ". Wanna Play a Detective? Find the Bug in a Function from Midnight Commander Conclusion We found tons of bugs in 2019. Those were common copy-paste mistakes, inaccurate constants, unclosed tags, and lots of other defects. But our analyzer is evolving and to diagnose more and more types of issues, so we are certainly not going to slow down and will be publishing new articles about bugs found in projects just as regularly as before. learning Just in case you haven't read our articles before, all these bugs were found using our PVS-Studio static analyzer, which you are welcome to and try on your own projects. It detects bugs in programs written in C, C++, C#, and Java. download You've finally got to the finish line! If you missed the first two levels, I suggest that you seize the opportunity and complete these levels with us: and . C# Java Previously published at https://www.viva64.com/en/b/0700/

Top 10 C++ Open Source Project Bugs Found in 2019 

Hey!, Today Luca asks: Can I write on a Bitcoin Blockchain? Can I drop down a message? Yes, Luca of course you can! You can leave a message on a Bitcoin blockchain using a particular op code, called . OP_RETURN Through this operation code, your UTXO became ! You can use at most 80 bytes for your message (160 hexadecimal characters)! unspendable This operation is known as “timestamping of write information” because the message will become part of a block with a timestamp as well. In Action Can I write on Bitcoin Blockchain? — Italian Language 🇮🇹 First of all, I get a SegWit address from my testnet node. $ bitcoin-cli getnewaddress tb1qrggdlvezgd4uy9mntz50mpmwd6l4vk9rm4ft3d "" "bech32" I need bitcoins! I need to use a faucet service such as: https://bitcoinfaucet.uo1.net/send.php After that, I can check my mempool and find my TX ID. $ bitcoin-cli getrawmempool | grep c5ce66d638f1b8ca702dfb8f7d1da7a6707d9c6497212dc66829c99f69b28b9a the is the faucet’s transaction. c5ce66d638f1b8ca702dfb8f7d1da7a6707d9c6497212dc66829c99f69b28b9a When can I use my UTXO? I can use it after the mining process. Please recover my UTXO with command. listunspent $ bitcoin-cli listunspent | jq
[
{ : , : , : , : , : , : , : , : , : , : , : }
] 1 101 '["tb1qrggdlvezgd4uy9mntz50mpmwd6l4vk9rm4ft3d"]' "txid" "c5ce66d638f1b8ca702dfb8f7d1da7a6707d9c6497212dc66829c99f69b28b9a" "vout" 1 "address" "tb1qrggdlvezgd4uy9mntz50mpmwd6l4vk9rm4ft3d" "label" "" "scriptPubKey" "00141a10dfb322436bc2177358a8fd876e6ebf5658a3" "amount" 0.00100000 "confirmations" 6 "spendable" true "solvable" true "desc" "wpkh([3a46ecca/0'/0'/4']020d12775323bbdaf0cb6e9a2b44ae7a591ef5872364e80e363a93d283c10b9e4f)#kxjva7dw" "safe" true Nice! I need to retrieve the private key, as we know it’s mandatory to sign my transaction. $ bitcoin-cli dumpprivkey tb1qrggdlvezgd4uy9mntz50mpmwd6l4vk9rm4ft3d
cPHTHs7ERe6jDYiitj9eLVswsX3RpeKMB19eXYjpLb4CkEHd7drq Now, we are able to create an amazing message, for instance: corsocompleto.bitcoininaction.com. Yep, we need to use hexadecimal! $ printf | xxd -ps f72736f636f6d706c65746f2e626974636f696e696e616374696f6e2e636f6d "corsocompleto.bitcoininaction.com" 636 I have the necessary to create the transaction! Using I can retrieve a lot of information about this method. I want to use it on . help createrawtransaction $ bitcoin-cli help createrawtransaction The receiver is the faucet’s address, I give back bitcoins :). The address is: NGZrVvZG92qGYqzTLjCAewvPZ7JE8S8VxE 2 Finally, I can build my transaction, in the data field I can put my message. Remember that it will create an operation code as we discussed above. hexadecimal OP_RETURN $ bitcoin-cli createrawtransaction a8bb2699fc92968c62d2197649c7d70a6a71d7d8ffb2d70cab8f138d666cec50100000000ffffffff02b88201000000000017a914ffd0dbb44402d5f8f12d9ba5b484a2c1bb47da42870000000000000000236a21636f72736f636f6d706c65746f2e626974636f696e696e616374696f6e2e636f6d00000000 '[{"txid":"c5ce66d638f1b8ca702dfb8f7d1da7a6707d9c6497212dc66829c99f69b28b9a","vout":1}]' '[{"2NGZrVvZG92qGYqzTLjCAewvPZ7JE8S8VxE":0.00099000},{"data":"636f72736f636f6d706c65746f2e626974636f696e696e616374696f6e2e636f6d"}]' 02000000019 As you can see I have just one input, for that reason I don’t need of change address because I don’t have any change! n.b. Furthermore, I don’t spend my entire output because I need to pay fees (input-output = fees). Nice, we created the transaction data! Yeah! The next step is to sign it and send it! We need to use the method. signrawtransactionwithkey $ bitcoin-cli signrawtransactionwithkey a8bb2699fc92968c62d2197649c7d70a6a71d7d8ffb2d70cab8f138d666cec50100000000ffffffff02b88201000000000017a914ffd0dbb44402d5f8f12d9ba5b484a2c1bb47da42870000000000000000236a21636f72736f636f6d706c65746f2e626974636f696e696e616374696f6e2e636f6d00000000 { : , : } 02000000019 '["cPHTHs7ERe6jDYiitj9eLVswsX3RpeKMB19eXYjpLb4CkEHd7drq"]' '[{"txid":"c5ce66d638f1b8ca702dfb8f7d1da7a6707d9c6497212dc66829c99f69b28b9a","vout":1,"scriptPubKey":"00141a10dfb322436bc2177358a8fd876e6ebf5658a3","amount":0.00100000}]' "hex" "020000000001019a8bb2699fc92968c62d2197649c7d70a6a71d7d8ffb2d70cab8f138d666cec50100000000ffffffff02b88201000000000017a914ffd0dbb44402d5f8f12d9ba5b484a2c1bb47da42870000000000000000236a21636f72736f636f6d706c65746f2e626974636f696e696e616374696f6e2e636f6d0247304402205688399cb5a230f050330e2bc6d04d9864d459f85fec48a0118ca31be9239d530220228d7c04fe9e6eea3690033c01ed222284efaa01b28a9a7cae809bdb32d7ce7a0121020d12775323bbdaf0cb6e9a2b44ae7a591ef5872364e80e363a93d283c10b9e4f00000000" "complete" true Nice, the signature is valid, now we gonna send the transaction with method. sendrawtransaction $ bitcoin-cli sendrawtransaction a8bb2699fc92968c62d2197649c7d70a6a71d7d8ffb2d70cab8f138d666cec50100000000ffffffff02b88201000000000017a914ffd0dbb44402d5f8f12d9ba5b484a2c1bb47da42870000000000000000236a21636f72736f636f6d706c65746f2e626974636f696e696e616374696f6e2e636f6d0247304402205688399cb5a230f050330e2bc6d04d9864d459f85fec48a0118ca31be9239d530220228d7c04fe9e6eea3690033c01ed222284efaa01b28a9a7cae809bdb32d7ce7a0121020d12775323bbdaf0cb6e9a2b44ae7a591ef5872364e80e363a93d283c10b9e4f00000000

edee419f93521f43259b763ffb42e4b882504534494381b7e18057015a27c548 020000000001019 We obtained the transaction id. We can use a block explorer ( ) with the in order to find out the transaction and check its structure. https://tbtc.bitaps.com/ transaction id Our message! Amazing Bitcoin course 🚀 — corsocompleto.bitcoininaction.com The transaction has been sent properly and now it’s waiting for mining. It contains two outputs. One of them is for faucet’s address, the other one is an unspendable UTXO, because it contains our message with operation code: . OP_RETURN Through this example, we can now understand which operation code is used to “write” on the Bitcoin Blockchain. You can find the code in our GitHub! Do you want more? You rock 🎸! , they are available at Amazon and corsobitcoin.com (accept bitcoin) Check our books See you next time! 🤟🏻 — — 🎥 Bitcoin in Action — 🐙 GitHub: https://bit.ly/2Lj3yeY — 📖 Libro Bitcoin dalla teoria alla pratica (Amazon) 📖 Libro Bitcoin dalla teoria alla pratica (pagamento in bitcoin) 📖 Libro Bitcoin dalla teoria alla pratica (Amazon) 📖 Book Bitcoin from theory to practice — 📖 Tascabile Bitcoin 199 domande (Amazon) 📖 Tascabile Bitcoin 199 domande (pagamento in bitcoin) 📖 Pocket Book Bitcoin 199 questions (Amazon) 📖 Pocket Book Bitcoin 199 questions (accept bitcoin) — 🎥 Video Corso Bitcoin dalla teoria alla pratica — ► , , , , , Twitter Facebook Medium Instagram Youtube GitHub Television isn’t a good idea (Radio Stations) Email isn’t a good idea (Post offices) Amazon isn’t a good idea (Retail stores) Bitcoin isn’t a good idea (Central banks) In we trust crypto

Adding Messages On The Bitcoin Blockchain - A How-To Guide

Map Room envisions a future for the city that is also wise as a result of a shared understanding of lived experience amongst its citizens. — Jer Thorp, Making Mapping more Human The was an experiment in collaborative mapping as a source of community engagement. A vacant school’s gymnasium provided a forum where, over the course of a month, 29 groups came in to make 100 square foot maps of their neighborhoods and communities. They were aided by robots and projection, but primarily drew huge maps by hand that speak to their lived experience of their city. St. Louis Map Room Community groups mapped hand-collected bicycle traffic data, community gardens, churches, magnet schools, and food banks. Groups of students mapped their schools, how they got there, and where it was or wasn’t safe. Before the project opened, we decided to use robotics to add some fun and to save people work. Map Room’s robots would do the precise but less creative work of laying out the basics of a map, which would fade into the background as humans filled in with their own personal stories. There were a number of constraints on our design: The robots needed to like robots, that’s part of the excitement. look The tracking system has to be extremely affordable. The map drawing has to be accurate enough to really represent a map. The robots and tracking system have to communicate wirelessly. We’ll talk through how we addressed those constraints, with a special emphasis on the computer vision we used to make the project a success. Picking a robot Most drawing machines operate like : they have only three degrees of freedom: the x and y axes plus a pen that can be raised and lowered. And since they operate on rails, their stepper motors or rotary encoders can be calibrated to position a pen very accurately — down to a millimeter or smaller. Check out classic or the more recent for examples of machines like these. CNC routers pen plotters AxiDraw But if you want to fit the capital-R Robot aesthetic, you can’t beat a fully mobile robot. There are a few kinds to choose from. You could use a two-wheeled differential-drive robot, if you’re willing to solve the . Alternatively, you could use a if you’re willing to do more math. Either way, you’ve got more factors to worry about. You’ve got another degree of freedom (the rotation of the robot) and you’re not on rails like a pen plotter, so you have to devise some kind of positioning system. parallel parking problem holonomic-drive robot Positioning a robot That’s the biggest challenge you face with a mobile robot: knowing where it is. One way to solve it is : calculating where you are based on where you’ve been and how you’re moving. It’s the equivalent of oceanic navigation . Polynesian navigators, faced with this problem, came up with solutions like to gather more information. Our robot probably can’t be as clever. dead reckoning before clocks could be used at sea tracking bird migrations You could also mount a camera on the robot itself and it could figure out where it is. If you’re building a self-driving car, you’ve got to take the cameras with you. For our robot, however, we have one big advantage: the area that we need to cover is known and we can build specifically for it. In our case, we wanted to cover a 10’x10’ canvas. Unlike a ship, we can track ourselves externally — like if we had a satellite overhead. On a practical level, that means we’ve got some more tools at our disposal. Movie studios have been using for decades. The Microsoft Kinect brought some of that into people’s living rooms, and these days room-scale virtual reality tracking is advancing by leaps and bounds as well. HTC just released the that should be able to do 6-DoF tracking for <$1000. motion capture technology Vive Tracker But what if you’re really on a budget? Let’s see what we can do for $100. A sketch of a tracking system Schematic of the Maproom tracking system We figured the most cost-effective way to track our robot was visually: put a marker on the robot, track it with a camera, and relay that information to the robot. With a Raspberry Pi 3 ($39), power supply ($10), case ($7), 16gb SD card ($13), and Raspberry Pi Camera Module v2 ($30), you’ve got all the hardware you need for almost exactly $100. Setting up a Raspberry Pi with OpenCV can be a pain, but I highly recommend . pyimagesearch’s Raspbian Jesse + OpenCV 3 set up guide In our case, we also needed the tracking system to be wireless — the robots couldn’t have wires, and we had to suspend the camera 14’ in the air in a place we couldn’t easily run Ethernet cables. The Raspberry Pi worked great for this as well. A word on accuracy: the eventual framerate we were able to get was ~15fps at 960 x 720 px. If the full 10 foot by 10 foot robot area was aligned to 720px, then one pixel represents 0.17 inches (= 10 feet / 720 px). In our case, we could get the map to fill about 500 pixels, so a pixel represented 0.25 inches — pretty good, but definitely jarring. The Maproom’s goal is to focus on human stories, and the underlying map should not distract from these. We had to do better. ArUco Aruco markers (picture from ) http://code.opencv.org/projects/opencv/wiki/GSoC_2016 Enter the ArUco marker detection library. It was the fastest way we found to get set up tracking fiducials ( , — there are even ). You can track markers that look like a bit like QR codes in very few lines of code. The “AR” in ArUco stands for “augmented reality”, but we’re not going to use 3D positioning system it provides — more on that later. src docs ports to Javascript We considered a few other options, like , or , but ArUco had features that we really liked: quick setup and tracking multiple unique markers out of the box. In theory, it would let us do better positioning than the 0.25 inches we calculated above by using refinement algorithms to locate the center of each marker to accuracies better than a pixel. tracking custom markers with SIFT/SURF tracking known shapes Calibrate and capture Any camera that uses a lens — including the Raspberry Pi Camera — has some in the image it produces. This is a problem if you want to be able to use pixel values as positions, like in the case of our robot. distortion Fortunately, a lot of work has gone into making it easy to calculate exactly how a camera’s lens distorts the world, and it’s quick do with OpenCV. We to use a to perform the calibration quickly and easily (more on ArUco. You just print out the board, hold it in front of the camera until enough frames are recorded, and OpenCV does the rest (see a ). wrote a script ChArUco board whole example We found from testing that for best results you should use the largest, flattest board you can — a trip to Kinko’s doesn’t hurt to get a large sheet printed. Our was 16” x 23”, printed on matte paper and mounted on posterboard. The errors here will propagate down to the rest of the system, so it’s worth getting your camera calibrated really well! final board Detect some markers After calibration, you can use ArUco to detect markers in your frame. As we mentioned before, ArUco was designed for augmented reality, so it’s designed to give you coordinate systems for each marker relative to the camera. In theory, that means we know where the markers are in 3d space! That’s a good idea, but in practice we had some issues… The jumpy animation above shows the positions and rotations in space for markers that were all lying still on a flat plane. They should have all been (at least) facing the same way, but clearly have a lot of jitter. Some smoothing would have helped, but to control a robot you need fast update times. We can use the fact that we’re operating on a flat surface to avoid this problem — let’s not do the pose estimation at all! The marker detection routine actually gives us the four (pixel) corners of the marker in the image. It was straightforward to just take the those corners and average them to give the center of the marker. The rotation of the marker can also be found by averaging the “top two” corners of the marker, and drawing a vector between the center and the “top”. We found these positions to be stable and accurate to about 1/8” from 14’ up (about 3mm at 4m) — that’s really good given the price point of the hardware we’re working with! Perspective Left: without perspective transform. Right: after perspective transform. Once we’ve figured out where the markers are in the scene, we still have to be able to compare that to what we want to draw. It’d be nice if the camera were mounted perfectly above the center of the canvas, pointed straight down — but it wasn’t in our setup, and probably wouldn’t be in yours either. We can fix this by applying a to the marker positions, which will take the angled view that the camera sees (left above) and make it flat and square (right above) — just like the SVGs we’ll be drawing. This is different than the calibration step above; it’s not the distortion of the lens we’re correcting for, but instead the tilt of the camera relative to the scene. perspective transform That transformation is just a 3x3 matrix. OpenCV makes it easy to calculate the matrix from four pairs of points. We wrote , which let to better precision than clicking on corners on the screen since ArUco positions are accurate below a pixel. a script to build the matrix using ArUco markers At this point, we’ve got an undistorted, perspective transformed, sub-pixel accurate position for a marker! We can send those coordinates back to the robot, and they’ll know exactly where they are. Screenshot of the openFrameworks app that coordinates the robots drawing an SVG Putting it all together Every frame, these steps have to happen: Detect ArUco marker corners using camera calibration Calculate each marker center and up direction Undistort each marker using a camera calibration Transform each marker using a perspective transform Send the marker center and up to the robot coordinator The fact that this can happen 15 times per second on a $30 computer is pretty astounding! If you have a beefier computer, you could probably get way higher framerates out of this — my Macbook Pro was able to hit 30fps, which was the limit of the camera. There are a whole lot of other tricks we had to apply to get the tracking system working the way we needed: to get a good framerate threading the image capture applying to deal with the height of the robot yet another perspective transform to fit our lighting conditions and give a good framerate adjusting the parameters of ArUco to make the tracking software survive Raspberry Pi reboots using systemd Thanks for following along! Want the source code? It’s written in Python, lives and lives on Github as . O-C-R/maproom-robots/skycam <a href="https://medium.com/media/d797d150bc50113878ff6a073b9f5673/href">https://medium.com/media/d797d150bc50113878ff6a073b9f5673/href</a>

Drawing maps with robots, OpenCV, and Raspberry Pi

Five years ago, Frank Chen posed a question that has stuck with me every day since. The question was this, “If self-driving cars are 51% safer, are we not morally obligated to adopt them?”.  I’ve posed this question a ton of times over the past five years, and usually, a knee-jerk reaction leads to an interesting debate. What makes this question so great is the knife's edge – it’s not 99% safer, it’s not 70% safer, it’s 51% safer. only To put it into context. The National Highway Safety Administration has that in 2022, there were an estimated 42,795 traffic fatalities. 50% of 42,795 is 21,398 people, and 51% is 21,825 people. reported That means if self-driving cars are 51% safer, using them would save 427 people’s lives every year. That is about 1.5 Boeing 777 airplanes full of passengers. Is saving 427 lives a moral argument for adoption? In the five years I’ve been sharing this question, the answers are never simple. They’re always fraught with “what ifs.” But even if the answers lack clarity, I think the question is incredibly important. In part because it opens a broader — and equally important — debate on the moral imperative of AI adoption across many aspects of our lives and work. Because, after all, avoiding technology that could save lives may be just as ethically problematic as adopting technology too hastily, The Moral Imperative of AI Adoption I've always found the debate around autonomous vehicles to be a perfect microcosm for the broader discourse on AI. If we possess technology that's statistically safer than human-operated vehicles, isn't the moral choice obvious? Consider this: have shown that human drivers had a higher rate of crashes with a meaningful risk of injury than self-driving  (AI-powered) cars. Specifically, human drivers caused 0.24 injuries per million miles (IPMM) and 0.01 fatalities per million miles (FPMM), while self-driving cars caused 0.06 IPMM and 0 FPMM. studies And remember, these numbers aren't just statistics. They represent real lives that could be saved by embracing AI technology. But why stop at autonomous vehicles? The potential for AI to enhance safety, efficiency, and accuracy spans across fields like medicine, public health, food safety, agriculture, cybersecurity, crime prevention, and military science. If AI can diagnose diseases with greater accuracy than human doctors, predict crop failures before they devastate food supplies, or thwart cyber-attacks before they breach our data, don't we have a moral obligation to also utilize those technologies? Of course, these are dramatic examples, but the argument extends beyond life-and-death scenarios. AI's ability to improve our daily quality of life is equally compelling. Whether by simplifying mundane tasks or making information and services more accessible and equitable, AI can end drudgery and enhance our daily quality of life. The moral imperative to adopt AI isn't just about preventing harm or death; it's about whether we have an obligation to contribute to human well-being if we can. The Dilemma of Choice and Safety So, do we choose human-operated vehicles (or human-led processes) knowing they are less safe or efficient than their AI counterparts? Simply because they are more human? Faced with the choice between human-operated systems and AI-enhanced alternatives, my thought is the decision should obviously hinge on safety and efficiency rather than an allegiance to some murky idea of what is "human" or not. Embracing AI doesn't mean disregarding human value or input; rather, it's about acknowledging that what's human isn't inherently superior — and honestly, is often significantly inferior in specific contexts. Now please don’t get out the pitchforks, I’m not joining Team Robot Overlord. I get the anxiety a lot of people feel about the disruption AI is already causing to their jobs and the societal change that is undoubtedly headed our way. I just wonder whether the efficiencies of AI and the quality of life benefits might, in the long run, outweigh the impact of those disruptions. Some of our reluctance to adopt AI is informed by cognitive biases and fears. For a species famed for its adaptability, we humans don’t love change. Cognitive biases play a substantial role in our hesitance to embrace AI. Cognitive biases are psychological patterns that are a holdover from our early years as Homo Sapiens. They are the habits our minds fall into — cognitive shortcuts that can be useful when running from predators but definitely skew our modern perception and judgment. In this case, recognizing and addressing these biases is crucial in moving toward a more rational, ethical approach to AI adoption. Here are a few that I think could be in play, influencing our suspicion, trust, or acceptance of AI technologies. People tend to attribute human characteristics to AI or robots, influencing their trust and expectations. This can lead to unrealistic assumptions about AI systems' capabilities or the attribution of evil intentions. Anthropomorphism Bias: This bias leads individuals to overestimate the probability of events associated with memorable or vivid incidents. Sensationalized media reports about AI failures or successes can be blown out of proportion and disproportionately influence perceptions of AI reliability and safety. Availability Heuristic: What’s everyone else doing? People may seek out or interpret information in a way that confirms their preexisting beliefs or hypotheses about AI. This bias can hinder the objective evaluation of AI technologies and their potential benefits or risks. Confirmation Bias: People don’t want to miss out on beneficial technologies but can lack an understanding of the implications. This bias can overshadow critical evaluation and lead to premature adoption. This bias is related to the Bandwagon Effect (e.g., The tendency to do or believe things because everyone else does - or influencers do. People might trust or distrust AI technologies simply because that seems to be the popular sentiment. FOMO: People prefer to maintain the current state, which leads to resistance against adopting something new like AI, regardless of potential benefits or proven superiority. This bias can slow innovation and the adoption of potentially life-enhancing technologies. Status Quo Bias: This bias makes the pain of losing something feel more potent than the pleasure of gaining something of equal value. For AI, this means the fear of job loss or loss of control overshadows the benefits of safety/efficiency/convenience. Loss Aversion: Overestimation of one's ability to control or understand something. For AI, this means overestimating or underestimating the risks associated with AI. Overconfidence Bias: Numbers are scary! People tend to be biased against algorithms, believing human decision-making is superior, even when evidence suggests otherwise. On the other hand, some might also have an unquestioning trust in AI decisions, ignoring the potential for errors or biases in AI systems. Algorithm Aversion/Trust: Economic Rationality Interesting, right? But the truth is, this is all academic. We may not even get to make this decision in the end.  Companies are already making it. A ton of corporations are barreling ahead with AI integration — mainly because the ROI often speaks louder than ethical debates. Take with its significant shift towards automation. The efficiency and economic benefits are tangible and measurable, and in the face of cold hard cash, moral and social criticisms suddenly feel more academic. Amazon as a prime example, Still, this isn't only about stone-hearted capitalism; it's about survival and adaptation. Businesses are tasked every day with the challenge of balancing technological adoption with ethical and ESG responsibilities. The impact of AI on employment and human well-being can't be an afterthought. For thousands, financial stability and career wellness hinge on these decisions. It’s something a lot of enterprises are grappling with. And here's where the moral imperative question becomes more nuanced. If AI can streamline operations, reduce costs, and even create new opportunities, then aren’t we also morally responsible for exploring these technologies? The trick will be to keep that ethical compass handy and ensure that as we embrace AI's efficiencies, we also safeguard against its potential to unfairly disrupt livelihoods. We are in a Transition Period Either way, we need to watch our footing. We are standing on the precipice of a new era, and one solid push could end us in a freefall. AI is no longer a futuristic fantasy; it's absolutely embedded in our daily lives and work. That’s exciting — and scary as hell. One of the most significant challenges we face is the accessibility or tech gap. AI has the potential to democratize technology, making powerful tools available to a broader audience. However, right now, AI's promise is primarily being seen by those who already have a certain level of access, so there is also the potential that AI will exacerbate existing inequalities rather than alleviate them. It’s a period of adjustment, so it will require patience, education, and proactive measures to ensure that the benefits of AI are widely distributed. We’ve got the potential to level the playing field so that AI's potential can be unlocked for everyone, not just the privileged few. The Conundrum of Cooperation Okay, so it is a paradox:  For AI to function optimally alongside humans, it must be superior to us in certain tasks.  But that VERY superiority threatens to displace human roles, fueling resistance and fear among us mortals. This paradox creates a tough "push-pull" for AI; that’s why we’re seeing such heated debate about morality. I believe the solution may be a suite of emerging design philosophies and technologies aimed at bridging the gap between AI and human cooperation in an ethical way. I’ll list them below. They are worth asking ChatGPT about: ensures that AI systems are developed with human needs and values at their core. Human-Centric AI Design (HCAI): demystifies AI decisions, making them understandable and transparent to humans. Explainable AI (XAI): guide the development and deployment of AI systems in a manner that respects human rights and values. Ethical AI Frameworks: learns from and adapts to human feedback, ensuring a synergistic relationship. Adaptive/Responsive AI: involves end-users in the AI development process, ensuring their needs and concerns are addressed. Participatory Design: emphasizes AI's role in enhancing human abilities rather than replacing them. Augmented Intelligence: builds confidence in AI systems through reliability, safety, and ethical assurances. Trustworthy AI: To Self-Drive Cars, or to Not Self-Drive Cars? In wrapping up, I’ll take a stand. I think adopting AI is a moral imperative. In my view, the potential to save lives, enhance our quality of life, and even address long-standing inequalities is too significant to ignore. However, this doesn't mean we should dive headfirst without consideration.  In my opinion, we need to approach AI with a blend of enthusiasm and caution—staying excited to explore its possibilities but mindful of the ethical, social, and economic impact. Thoughtful consideration, robust ethical frameworks, and stringent governance are the keys to unlocking AI's potential responsibly. I’m still open to debate on the subject. So, I’ll throw the question out to you. Reply here or on my and tell me why I’m wrong — or right. I invite your thoughts and comments on this complex issue. LinkedIn thread Are we ready to embrace AI with the moral seriousness it demands? Are you ready to take your next road trip in a self-driving car?

Are We Morally Obligated to Adopt AI?

আমরা কি নৈতিকভাবে এআই গ্রহণ করতে বাধ্য?

Sind wir moralisch verpflichtet, KI einzuführen?

¿Estamos moralmente obligados a adoptar la IA?

Sommes-nous moralement obligés d’adopter l’IA ?

क्या हम नैतिक रूप से एआई को अपनाने के लिए बाध्य हैं?

私たちには AI を導入する道徳的義務があるのでしょうか?

우리는 AI를 채택해야 할 도덕적 의무가 있습니까?

Somos moralmente obrigados a adotar a IA?

Обязаны ли мы морально принять ИИ?

Ahlaki Olarak Yapay Zekayı Benimsetmek Zorunda mıyız?

Chúng ta có nghĩa vụ về mặt đạo đức phải áp dụng AI?

我们在道义上有义务采用人工智能吗？

(CI) and Continuous Deployment (CD) play crucial roles in modern software development, enabling teams to deliver high-quality code and new features efficiently. AWS (Amazon Web Services) offers powerful tools such as CodePipeline and CodeBuild that automate pipelines. Continuous integration CI/CD This article will explore implementing CI/CD pipelines using AWS CodePipeline and CodeBuild, streamlining the development and deployment processes. What is AWS CodePipeline? AWS CodePipeline is a fully managed CI/CD service that automates your release process's build, test, and deployment phases. It facilitates the creation and visualization of end-to-end release pipelines, integrating seamlessly with different AWS services and third-party tools. Key Features of AWS CodePipeline Pipeline Visualization CodePipeline provides a visual representation of your CI/CD pipelines, enabling easy comprehension of the workflow and monitoring of each stage's progress. AWS Services Integration CodePipeline integrates with various AWS services, including CodeCommit, Amazon S3, CodeBuild, CodeDeploy, and more. This extensive integration makes it a versatile tool for your development purposes. What is AWS CodeBuild? AWS CodeBuild is a managed service for continuous integration. It compiles source code, performs tests, and generates deployable artifacts. This service has automatic scaling capabilities. It enables fast and efficient application development. Key Features of AWS CodeBuild Build Environments CodeBuild offers pre-configured build environments that support various programming languages and runtimes. Moreover, it allows the creation of custom environments tailored to specific requirements. Automatic Scaling CodeBuild automatically adjusts its infrastructure to match the size and demands of your project. As a result, you can expect consistent and speedy build times regardless of project complexity. Implementing CI/CD Pipelines with AWS CodePipeline and CodeBuild Step 1: Creating a CodePipeline Pipeline Log in to your AWS account and navigate to the pipeline service. Click on the "Create pipeline" button and provide a name and optional description for your pipeline. Choose the source repository, such as AWS CodeCommit or an external GitHub repository, and indicate the branch responsible for triggering the pipeline. Opt for AWS CodeBuild as the build provider and adjust the build settings, including the build environment, specifications, and artifact output. Specify the deployment provider. AWS CodeDeploy, AWS Elastic Beanstalk, or other supported services Set up the necessary deployment settings. Thoroughly review your pipeline configuration and proceed to create the pipeline. Step 2: Creating a CodeBuild Project Navigate to the CodeBuild service in the AWS Management Console. Click on the "Create Build Project" button and assign a name and optional description to your project. Choose the source repository, branch, and authentication method. Utilize a buildspec.yml file to outline the build steps, environment variables, and other build-related configurations. Select the desired build environment, including the operating system, runtime, and relevant tools. Set up build caching, build timeouts, and other optional project settings. Review your project configuration and initiate the building project. Conclusion In conclusion, using AWS CodePipeline and CodeBuild presents a robust solution for implementing . Integrating these services allows developers to automate the build, test, and deployment processes, resulting in expedited and dependable software releases. Embrace the capabilities of AWS to optimize your development workflow and attain efficient, automated, and scalable CI/CD pipelines. CI/CD pipelines

Implementing CI/CD Pipelines with AWS CodePipeline and CodeBuild

Today, we're going to explore a fascinating aspect of React development that often goes unnoticed: . As React developers, we frequently use this handy tool in our projects. how the useEffect hook affects performance But have you ever wondered why it runs after the component has been rendered on the screen? I've always been curious about this. Why does it work that way? In this post, I'll walk you through the reason behind this choice made by the React team and see how it can actually make your application faster. We'll use practical examples to demonstrate the concept. Are you ready? Then hit that ❤️ button on the right, and Let's get started! An Example of Using localStorage Let's talk about , also known as . It's a handy browser feature that allows us to store data using and . However, there's a slight downside to it. localStorage window.localStorage keys values You see, localStorage works synchronously, which means that it may cause some issues. Yes, let me explain! console.log("A"); // A
localStorage.setItem("key", "value"); // An assumed ongoing process...
console.log("B"); // I am still waiting..... In the code snippet above, something interesting happens. First, we see the console logging of  the string . Then, we have doing its thing, which takes about 200 milliseconds to finish. A localStorage.setItem() During this time, the patiently waits for to complete before it can log anything. console.log("B") localStorage.setItem() Now, why is this not ideal? Well, it can potentially cause your application to slow down right away. Nobody wants that, right? If you only need to store a few items, it's not a big deal to use localStorage. However, it's generally not recommended to rely on it too heavily because it tends to be quite slow in terms of performance. So, keep this in mind when working with localStorage, and try to use it sparingly, especially if you want to keep your application running smoothly. If you haven't had the chance to use useEffect, I highly recommend reading this from before you proceed. detailed guide about useEffect @nirmalkumar Using localStorage Within a Component Let's imagine you want to use the feature in a React component. In that case, it's recommended to use it within a hook for a couple of reasons: localStorage useEffect It's considered a side effect because it modifies something outside the React component. It can also improve performance, as I'll explain. To give you an example of why performance could be affected, let's assume we have a large array of objects stored in a file. We can import this array and save it into within a React component. data.js localStorage Here's the code snippet: import {useState} from "react";
import data from "./data.js";

function App() {
    const [random, setRandom] = useState(Math.random());

    // THIS IS BAD FOR PERFORMANCE
    localStorage.setItem("data", JSON.stringify(data));

    return <>
        <h1>{random}</h1>
        <button>Re-render</button>
    </>
} The code snippet above could potentially run into a small issue. If the function takes around 200ms to complete, it can cause a noticeable delay in showing updates on the user's screen. localStorage.setItem() This delay might not be ideal for the performance of your application. To illustrate this issue, I have taken the example code and exaggerated it by including 200 and calls. You'll see the impact of this in just a moment. localStorage.setItem() localStorage.getItem() To address this performance concern, I have come up with an optimized version of the code. In this optimized version, I encapsulated the 200 localStorage calls within a hook. useEffect This is why the code execution will be more efficient, and the user will experience smoother updates on their screen. Here’s the code: import {useState, useEffect} from "react";
import data from "./data.js";

function App() {
    const [random, setRandom] = useState(Math.random());

    // this is BETTER for performance
    useEffect(() => {
        localStorage.setItem("data", JSON.stringify(data));
    });

    return <>
        <h1>{random}</h1>
        <button>Re-render</button>
    </>
} If we wrap the calls with , it allows the component to render on the screen first, and then perform the operations afterward. This approach helps prevent any performance issues that may arise when dealing with a large number of components. localStorage useEffect localStorage To demonstrate this, let's take a look at an exaggerated example where I increase the number of calls to simulate potential performance challenges. localStorage Component With 200 localStorage Calls Click on the button labeled Re-render as fast as you can in the below example. In this case, we directly make 200 localStorage calls inside the component itself. Pay attention to the responsiveness of the button. https://codepen.io/nyjokid/pen/rNQwmBa?embedable=true Using useEffect With 200 localStorage Calls: Now, do the same in this example. This time, we use the hook in React to make the 200 localStorage calls. useEffect Notice any differences in the responsiveness compared to the first example 😃 https://codepen.io/nyjokid/pen/eYQRWQg?embedable=true If you take a close look at the first example, you'll notice that the button stays active (highlighted in red) because it's getting stuck while processing all the JavaScript code. Just remember, isn't a cure-all solution. If the code inside is really slow, it can still affect the overall performance. useEffect useEffect Now, It's Your Turn 🥳 Have you ever faced any performance challenges while working on your React projects? How did you tackle them? I'd love to hear your thoughts and experiences, so feel free to share them in the comments section. And if you found this post helpful, don't forget to hit the ❤️ button on the top right and spread the word among your fellow React developers. Keep exploring, and enjoy coding 👋

This Is Why React Team's useEffect Strategy Shines (CodePen Examples Inside)

The Noonification: Codepen Embeds now Supported in 3.0 Editor (10/31/2022)

Hello, I quickly wanted to let everyone know that links can now be embedded into your HackerNoon stories when using the 3.0 editor. https://codepen.io/ Simply paste an embed link (on a new line!), like: https://app.hackernoon.com/mobile/bELI6hLg6Dl2YwABNiGd Then hover over the link and toggle the embed on. The result will look like this: https://codepen.io/RichardJohnn/pen/xxzGjGp?editors=1000?embedable=true In the story itself, the embed can be expanded by overing over the embed and clicking the expand icon in the top right.  This will increase the width of the embed, which is nice when you are looking at the split view. P.S. This pumpkin was created using which will be available to use for all published writers on HackerNoon (currently in use for all editors!). Newly published writers going forward will gain access to this option as well.  Stay tuned for its release!  ✌️ Stable Diffusion on replicate.com this quote right here

Codepen Embeds Now Supported in 3.0 Editor

Codepen Embeds ahora es compatible con 3.0 Editor

Codepen Embeds maintenant pris en charge dans l'éditeur 3.0

कोडपेन एम्बेड अब 3.0 संपादक में समर्थित है

Codepen Embeds が 3.0 エディターでサポートされるようになりました

Codepen incorpora agora com suporte no editor 3.0

Codepen Embeds hiện được hỗ trợ trong 3.0 Editor

3.0 编辑器现在支持 Codepen 嵌入

It's hard to make or find the right button. I've curated 24 of my favorites and most useful, so you can use them freely. Button On Hover Slide Effect. Creative Button Animation Effects | Only Using HTML & CSS Creative button | hover over UI Button Hover Effect #2 Playful button hover effects Button hover effect Hover effect using pseudo elements Need a simple button hover effect for your project? Here's my list of examples. Button Hover Draw - CSS Only A cool collection of Easy button hover effects using CSS only. Professional and clean. Don't forget to leave some comments, questions, or concerns. Would you like to see more? or have some ideas ? Let me know! Awesome button hover effects Button with a subtle gloss/shine wipe on hover. No images, just a single HTML element and a CSS pseudo-element. These are ten buttons with CSS hover effects. The effects are used transitions, text-shadows, animations, and transforms. Button with simple effect on hover! Single element required Playing with css animations and hover effect. A collection of CSS3 powered hover effects to be applied to links, buttons, logos, SVG, featured images and so on. Easily apply to your own elements, modify or just use for inspiration. Available in CSS, SASS, and LESS. Simple button styles to kickstart you webdesign! Making some basic animations with box-shadows. No extra elements or even pseudo-elements required. Some button hover effects using psuedo elements and borders. A few examples of flashy hover effects. Currently updating this pen. Work in Progress A simple idea that ended up being really hard to pull off. No 3D elements or transformations are used in this experiment, only 2D elements and some clever math to give the illusion of a 3D coin with real thickness. I'm happy with the results given the limitations of HTML and CSS. Pay Button Confetti using JS, SCSS, and a HTML5 canvas. T-Shirt cannon button with GreenSock. For CSS buttons and more, check out FrontEndin

The 24 Best CSS Free to Use Buttons (with CodePen Examples) 

Los 24 mejores botones CSS de uso gratuito (con ejemplos de CodePen)

Les 24 meilleurs boutons CSS gratuits à utiliser (avec des exemples CodePen)

बटनों का उपयोग करने के लिए 24 सर्वश्रेष्ठ सीएसएस (कोडपेन उदाहरणों के साथ)

24 の最高の CSS 無料で使用できるボタン (CodePen の例を含む)

Os 24 melhores botões CSS grátis para usar (com exemplos de CodePen)

24 Nút miễn phí sử dụng CSS tốt nhất (với Ví dụ về CodePen)

24 个最好的 CSS 免费使用按钮（带有 CodePen 示例）

Github Codespaces Vs. Gitpod: Choosing the Best Online Code Editor

Hey, the Hacker Noon editor now supports embeds from and so software developers can better tell the story of their code. To use, simply paste the link and hit enter (GIF above).  *Update: We now also support GitHub Gists. CodeSandbox CodePen Previously, developers could only host their code natively within Hacker Noon stories (still an option): In terms of improving the publishing experience, we support some embeds that you may not know about. Below are examples of how I embedded CodeSandBox, CodePen, Twitter and Youtube by pasting the link and pressing enter. CodeSandBox: CodePen: Tweets: Youtube Videos: Just paste the link and press enter. What embed should we support next?

Just Paste Link and Hit Enter to Embed  CodePen, CodeSandBox, Tweets or Youtube on Hacker Noon 

AWS CodePipeline: Setup And Maintenance From Scratch

CSS which stands for is a style sheet language used to describe how HTML elements are to be displayed. CSS is one of the core languages of the web because it is used to style the web. With CSS, you can add fonts, colors, size and spacing. It's basically used to layout the web. Cascading Style Sheets CSS is very easy to use but can be very tricky. Below are few CSS tricks and techniques you might find useful. 1.   Use !important to Override Normal CSS Rules The keyword is used in CSS to override previous CSS rules inherited from the parent element. !important 2. Using CSS Box Shadow The CSS box-shadow property adds a shadow effect around an element. 3. CENTERING AN ELEMENT In Web Development, there are many times you'll get to a point where you need to center a particular element. There are many ways to center an element, but here, I'll be showing you how to do it using position absolute and transform. The transform property allows you to rotate, move and scale elements, hence applying a 2D or 3D transformation to the element. means that, relative to the original position of this element, we move it to the left by 50% of its width, and then move it up by 50% of its height. transform: translate(-50%, -50%) 4. USING MEDIA QUERIES The presence of media queries (denoted with @media) in your style sheet allows you tell the browser how to render the content of your web page depending on the device used (screen size) to access the web page. Media queries are very essential in Web Development and it's the brain behind responsive web pages. Below, I'll be changing the color of a web page depending on how wide the screen is. In the codepen editor above, I set the default background color to be cyan. I then went further to add media queries for different break-points. I set the at and four break-points 500px, 700px, 950px 1200px. 5. THE HOVER PROPERTY The selector in CSS is actually a pseudo-class. Using :hover, you can define how a particular element is styled when the user hovers their cursor over it without actually clicking on it. :hover In the codepen editor above, when we hover on the button, the color and background color changes. A transform property was also added on hover which moves the right side of the button by -15 degrees.

Five CSS Tricks With Codepen Examples

With the world rapidly evolving by the minute, staying on top of the in-demand skills’ curve is a voluminous task. Web Development is one such skill that is almost essential to the modern developer. With a market size of about $40Bn in 2020, the need and opportunity for quality web developers are ever so evident. Whether you are new to the world of web development or an accomplished developer, you might have come across CodePen. CodePen is an online community for testing and showcasing user-created HTML, CSS, and JavaScript code snippets. Once you have a good foothold on HTML, CSS, JS/Jquery, it’s not necessary to design each component of your webpage from scratch. CodePen apart from being a code editor also has unique functionality, It functions as an learning environment, where developers can create code snippets, called “pens,” and test them. Most of the time CodePen would have tons of “pens” made by the developers that you can add to your website to make it more lavish. open-source In this article, We will look at a small example of how you can use any “pen” from CodePen and add it to your site. Step 1: Open CodePen.io Step 2: Type anything in the search box You can type anything that you wish on adding to your webpage. It can be a responsive slider, a team card, about section, animations, etc. In this article, I will add a beautiful slider. So go on and search beautiful slider in the search box. You’ll get a good astonishing options to chose from. We selected . https://codepen.io/supah/pen/zZaPeE Step 3: Code extraction Now as you can see, the Codepen editor shows us the amazing code that built this slider. But do you think copying the code simply from this editor and pasting it in yours would work? The answer is Most of the time the “pens” that you see use external libraries that the CodePen editor does not show. So simply copying them would result in inaccuracies that would be hard to resolve if we don’t import these libraries. NO. To do that, navigate to the bottom right corner of your screen and click on Export -> Export as .zip. This will download a zip file of the same pen in your system. Extract it using any extracting tool such as Winrar/Winzip and see the files. The zip contains two folders dist and src along with a readme and license text file. You can explore/read them for your interest. Now select the “ ” folder and there you’ll see , and files. Open all of these in a text editor(Sublime, Atom, Brackets, etc). dist index.html style.css, script.js On opening the HTML file with any text editor, we see many external libraries apart from and style.css script.js. Add these lines inside your index.html along with the body section( I created a sample HTML page with a “CodePen Slider” title that will be followed by this CodePen slider) and you have successfully extracted the main code. Now save the file, don’t forget to add “ ” and “ ” in the same directory. If you have those files in any other location, update the and according to that. script.js style.css href src Step 4: Open the index.html file Kudos!!! You just add a “pen” to your website. Pat yourself on your back. Play around with the code. Change the source of images, text on top of images according to your liking/requirement. Conclusion: In this article, you learned how to use “pens” from CodePen inside your website easily. If you want to add any “pen” apart from the example in this article, the process remains the same. Keep building beautiful websites. Thanks for reading!!!

How to use CodePen Code Inside Your Webpage

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Andrea Roncoli, Department of Computer, Science (University of Pisa);
(2) Aleksandra Ciprijanovi´c´, Computational Science and AI Directorate (Fermi National Accelerator Laboratory) and Department of Astronomy and Astrophysics (University of Chicago);
(3) Maggie Voetberg, Computational Science and AI Directorate, (Fermi National Accelerator Laboratory);
(4) Francisco Villaescusa-Navarro, Center for Computational Astrophysics (Flatiron Institute);
(5) Brian Nord, Computational Science and AI Directorate, Fermi National Accelerator Laboratory, Department of Astronomy and Astrophysics (University of Chicago) and Kavli Institute for Cosmological Physics (University of Chicago). Table of Links Abstract and Intro Data and Methods Results Conclusions Acknowledgments and Disclosure of Funding, and References Additional Plots 2 Data and Methods 2.1 Domain Adaptation Optimization and Computing Resources We performed experiments on NVIDIA A100 40GB GPU. For each of the models, implemented using PyTorch Geometric [19], we perform a hyperparameter search using the Optuna library [1], with 50 trials per model. More details on code performance, model implementations, and selected hyperparameters can be found in the publicly available code[4]. 2.2 Evaluation [1] https://arepo-code.org/ [2] http://www.tapir.caltech.edu/~phopkins/Site/GIZMO.html [3] CAMELS dataset documentation: https://camels.readthedocs.io/en/latest/index.html [4] GitHub repository will be added after the anonymous review stage. This paper is available on arxiv under CC 4.0 license. Authors: (1) Andrea Roncoli, Department of Computer, Science (University of Pisa); (2) Aleksandra Ciprijanovi´c´, Computational Science and AI Directorate (Fermi National Accelerator Laboratory) and Department of Astronomy and Astrophysics (University of Chicago); (3) Maggie Voetberg, Computational Science and AI Directorate, (Fermi National Accelerator Laboratory); (4) Francisco Villaescusa-Navarro, Center for Computational Astrophysics (Flatiron Institute); (5) Brian Nord, Computational Science and AI Directorate, Fermi National Accelerator Laboratory, Department of Astronomy and Astrophysics (University of Chicago) and Kavli Institute for Cosmological Physics (University of Chicago). This paper is available on arxiv under CC 4.0 license. available on arxiv Authors: Authors: (1) Andrea Roncoli, Department of Computer, Science (University of Pisa); (2) Aleksandra Ciprijanovi´c´, Computational Science and AI Directorate (Fermi National Accelerator Laboratory) and Department of Astronomy and Astrophysics (University of Chicago); (3) Maggie Voetberg, Computational Science and AI Directorate, (Fermi National Accelerator Laboratory); (4) Francisco Villaescusa-Navarro, Center for Computational Astrophysics (Flatiron Institute); (5) Brian Nord, Computational Science and AI Directorate, Fermi National Accelerator Laboratory, Department of Astronomy and Astrophysics (University of Chicago) and Kavli Institute for Cosmological Physics (University of Chicago). Table of Links Abstract and Intro Abstract and Intro Data and Methods Data and Methods Results Results Conclusions Conclusions Acknowledgments and Disclosure of Funding, and References Acknowledgments and Disclosure of Funding, and References Additional Plots Additional Plots 2 Data and Methods 2.1 Domain Adaptation Optimization and Computing Resources We performed experiments on NVIDIA A100 40GB GPU. For each of the models, implemented using PyTorch Geometric [19], we perform a hyperparameter search using the Optuna library [1], with 50 trials per model. More details on code performance, model implementations, and selected hyperparameters can be found in the publicly available code[4]. Optimization and Computing Resources 2.2 Evaluation [1] https://arepo-code.org/ [2] http://www.tapir.caltech.edu/~phopkins/Site/GIZMO.html [3] CAMELS dataset documentation: https://camels.readthedocs.io/en/latest/index.html [4] GitHub repository will be added after the anonymous review stage.

Adaptive Graph Neural Networks for Cosmological Data Generalization: Data and Methods

By now, most of us are accustomed to using CSS Custom Properties on projects. Since its introduction in 2017, CSS Custom Properties, also known as CSS variables, have optimised the code we work with and allowed engineers a finer degree of control when managing values within rules. CSS Custom Properties can be tricky to deal with and aren’t always as intuitive as one might hope. However, when used right, they can significantly reduce boilerplate code and keep things efficient, making our work more productive. While the approach below is not perfect, it works well when writing CSS for building projects. Why Use CSS Custom Properties As far as my experience goes, I can only think of three possible reasons to implement a CSS Variable: We want to use a given value in more than one place,


We know that a value will change in the future and want to reduce our efforts for refactoring,


We need to store dynamic values from JS execution. With this in mind, we can be more assertive about our use cases. Point 3 is less of a concern for this article, but points 1 and 2 are essential. Let's illustrate this using the familiar HTML button element. The Infamous Button Buttons are notoriously tricky to style consistently for such a simple HTML element. Perhaps it’s because they have several different states and applications, regardless - it's usually the first component we Frontend Engineers take on when it comes to a fresh build. Let's have a look at how we could write the style for a button using CSS Custom Properties: :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
 --button-bg: var(--color-primary);
 --button-color: var(--color-text-inverted);
 --button-border: var(--color-border);

 align-items: center;
 background-color: var(--button-bg);
 border: 1px solid var(--button-border);
 color: var(--button-color);
 display: inline-flex;
 line-height: 1;
} As far as this example goes, from a technical standpoint, it’s great. It’s clean and straightforward and would get a 👍 from me in a code review. But could we optimise it further? Well, yes. The var() function in CSS is pretty nifty…we’re used to using it in a somewhat one-dimensional way by just rendering out a value; however, it can be more dynamic. The way to do this is by using a fallback value. If we considered the above example, we could rewrite it like so: :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
  align-items: center;
  background-color: var(--button-bg, var(--color-primary));
  border: 2px solid var(--button-border, var(--color-border));
  color: var(--button-color, var(--color-text-inverted));
  cursor: pointer;
  display: inline-flex;
  line-height: 1;
  padding-block: 0.875rem;
  padding-inline: 1rem;
} This is far cleaner and will lead to the same outcomes as the previous example - with less boilerplate code. Overriding it in a variation makes each locally scoped CSS Variable (effectively) optional. We can easily now optionally define the variables defined in .button as separate variations: .button:where(.button-secondary) {
  --button-bg: orange;
  --button-border: teal;
}

.button:where(.button-tertiary) {
  --button-bg: teal;
  --button-border: orange;
} Although this technique is not revolutionary, we care how many lines of compressed text are heading over the wire. The less physical memory a CSS file takes up, the better, which ultimately translates to how many lines of CSS exist. In the first example, we’re looking at almost double the amount of code to achieve the same thing in our optimised example. This compound effect has an influential impact on performance and further improves readability and developer experience. If you'd like to play around a bit further, feel free to fork the following Code Pen: https://codepen.io/iamdainemawer/pen/NWmQZMz Support Since April 2017, according to Google Baseline, this feature is well-supported across all major browsers. If you're interested to learn more about Baseline, read my post about Google Baseline and Its Impact You can check for browser support by adding the following statement to your CSS stylesheets: @supports(--css: variable) {} Can I Use - CSS Nesting
CSS Specification - CSS Nesting Module Resources MDN - CSS Custom Properties
CSS Variables Polyfill By now, most of us are accustomed to using CSS Custom Properties on projects. Since its introduction in 2017, CSS Custom Properties, also known as CSS variables, have optimised the code we work with and allowed engineers a finer degree of control when managing values within rules. CSS Custom Properties can be tricky to deal with and aren’t always as intuitive as one might hope. However, when used right, they can significantly reduce boilerplate code and keep things efficient, making our work more productive. While the approach below is not perfect, it works well when writing CSS for building projects. Why Use CSS Custom Properties As far as my experience goes, I can only think of three possible reasons to implement a CSS Variable: We want to use a given value in more than one place, We know that a value will change in the future and want to reduce our efforts for refactoring, We need to store dynamic values from JS execution. We want to use a given value in more than one place, We want to use a given value in more than one place, We know that a value will change in the future and want to reduce our efforts for refactoring, We know that a value will change in the future and want to reduce our efforts for refactoring, We need to store dynamic values from JS execution. We need to store dynamic values from JS execution. With this in mind, we can be more assertive about our use cases. Point 3 is less of a concern for this article, but points 1 and 2 are essential. Let's illustrate this using the familiar HTML button element. The Infamous Button Buttons are notoriously tricky to style consistently for such a simple HTML element. Perhaps it’s because they have several different states and applications, regardless - it's usually the first component we Frontend Engineers take on when it comes to a fresh build. Let's have a look at how we could write the style for a button using CSS Custom Properties: :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
 --button-bg: var(--color-primary);
 --button-color: var(--color-text-inverted);
 --button-border: var(--color-border);

 align-items: center;
 background-color: var(--button-bg);
 border: 1px solid var(--button-border);
 color: var(--button-color);
 display: inline-flex;
 line-height: 1;
} :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
 --button-bg: var(--color-primary);
 --button-color: var(--color-text-inverted);
 --button-border: var(--color-border);

 align-items: center;
 background-color: var(--button-bg);
 border: 1px solid var(--button-border);
 color: var(--button-color);
 display: inline-flex;
 line-height: 1;
} As far as this example goes, from a technical standpoint, it’s great. It’s clean and straightforward and would get a 👍 from me in a code review. But could we optimise it further? Well, yes. The var() function in CSS is pretty nifty…we’re used to using it in a somewhat one-dimensional way by just rendering out a value; however, it can be more dynamic. The way to do this is by using a fallback value . var() fallback value If we considered the above example, we could rewrite it like so: :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
  align-items: center;
  background-color: var(--button-bg, var(--color-primary));
  border: 2px solid var(--button-border, var(--color-border));
  color: var(--button-color, var(--color-text-inverted));
  cursor: pointer;
  display: inline-flex;
  line-height: 1;
  padding-block: 0.875rem;
  padding-inline: 1rem;
} :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
  align-items: center;
  background-color: var(--button-bg, var(--color-primary));
  border: 2px solid var(--button-border, var(--color-border));
  color: var(--button-color, var(--color-text-inverted));
  cursor: pointer;
  display: inline-flex;
  line-height: 1;
  padding-block: 0.875rem;
  padding-inline: 1rem;
} This is far cleaner and will lead to the same outcomes as the previous example - with less boilerplate code. Overriding it in a variation makes each locally scoped CSS Variable (effectively) optional. We can easily now optionally define the variables defined in .button as separate variations: .button:where(.button-secondary) {
  --button-bg: orange;
  --button-border: teal;
}

.button:where(.button-tertiary) {
  --button-bg: teal;
  --button-border: orange;
} .button:where(.button-secondary) {
  --button-bg: orange;
  --button-border: teal;
}

.button:where(.button-tertiary) {
  --button-bg: teal;
  --button-border: orange;
} Although this technique is not revolutionary, we care how many lines of compressed text are heading over the wire. The less physical memory a CSS file takes up, the better, which ultimately translates to how many lines of CSS exist. In the first example, we’re looking at almost double the amount of code to achieve the same thing in our optimised example. This compound effect has an influential impact on performance and further improves readability and developer experience. If you'd like to play around a bit further, feel free to fork the following Code Pen: https://codepen.io/iamdainemawer/pen/NWmQZMz https://codepen.io/iamdainemawer/pen/NWmQZMz Support Since April 2017, according to Google Baseline , this feature is well-supported across all major browsers. If you're interested to learn more about Baseline, read my post about Google Baseline and Its Impact Google Baseline Google Baseline and Its Impact You can check for browser support by adding the following statement to your CSS stylesheets: @supports(--css: variable) {} @supports(--css: variable) {} Can I Use - CSS Nesting CSS Specification - CSS Nesting Module Can I Use - CSS Nesting Can I Use - CSS Nesting CSS Specification - CSS Nesting Module CSS Specification - CSS Nesting Module Resources MDN - CSS Custom Properties CSS Variables Polyfill MDN - CSS Custom Properties MDN - CSS Custom Properties CSS Variables Polyfill CSS Variables Polyfill

Using CSS Custom Properties To Optimize Styling Efficiency and Readability

In this blog, we will demonstrate how to get the coverage data for each incoming request on a Python web server built using any web framework. What Is Code Coverage? Code coverage is a metric used in software testing to measure the extent to which the source code of a program has been executed during testing. It indicates the percentage of code that has been covered by the test cases. Code coverage analysis helps developers understand how thoroughly their tests exercise the codebase. Code coverage tools are used to collect data on code execution during testing and generate reports showing the coverage metrics. These reports help developers identify areas of the code that are not adequately covered by tests, allowing them to write additional tests to improve coverage and increase confidence in the software's correctness and reliability. What Does It Mean to Get Coverage Data for Each Request? Obtaining coverage data for each request coming to a web server offers several benefits: Granular Insights: By capturing coverage data for each request, developers gain detailed insights into which parts of the codebase are executed in response to different types of requests. This level of granularity allows for a deeper understanding of the application's behavior under various conditions.


Identifying Untested Code Paths: Coverage data helps identify areas of the code that are not adequately covered by tests. By analyzing coverage reports, developers can pinpoint specific code paths that need additional testing, ensuring comprehensive test coverage across the entire codebase.


Building deduplication feature: coverage data for each e2e testcase can be analyzed to identify duplicate tests and remove them. Obtaining Coverage Data To obtain the coverage data, we would be using the coverage.py library. coverage.py is mostly used through CLI. But it provides API to use it programmatically. We will define a middleware through which every incoming request would pass. In our "coverage" middleware, before passing control to other parts of our application, we will call the start function from the coverage library. Coverage measurement is only collected in functions called after start() function is invoked, so if this middleware is scheduled to run first, then coverage of other middleware would also be captured along with the main application code. Once the application returns, then we will stop collecting coverage data. We can then fetch the data and further process it. The below is a code snippet for the coverage middleware which can be used in servers built using Flask web framework: import coverage

class CoverageMiddleware:
    def __init__(self, app):
        self.app = app

    def __call__(self, environ, start_response):
        cov = coverage.Coverage(cover_pylib=False)
        cov.start()
        response = self.app(environ, start_response)
        cov.stop()
        result = cov.get_data()
        Write(result)
        return response Here,Writefunction writes the coverage data to a file, say dedupData.yaml, which can then be used to identify duplicate testcases in the e2e scenario. Here is the modified sample Python application with middleware and writing logic in place: https://github.com/AkashKumar7902/samples-python/tree/v1.0.0/flask-mongo The repository includes test cases generated by Keploy, which can be replayed using the command keploy test -c "pythonapp.py". Upon successful execution of this command, a dedupdata.yaml file will be generated. This file will contain details of the executed files, including the lines covered, for each test case. Here is a sample dedupdata.yaml: - id: test-1
  executedLinesByFile:
    /home/akash/Desktop/githubrepo/samples-python/flask-mongo/app.py:
    - 33
    - 34
    - 35
- id: test-2
  executedLinesByFile:
    /home/akash/Desktop/githubrepo/samples-python/flask-mongo/app.py:
    - 24
    - 23 Using Coverage Data to Identify Duplicate Tests Earlier written dedupData.yaml which contains coverage data for each testcases, can be used to identify and flag duplicate testcases by analyzing similar codepaths. There are also multiple deduplication features for test cases based on coverage data for Keploy Cloud. Conclusion This is how with very little code change you can collect coverage data for each incoming request and prioritize increasing coverage for the most frequent requests, and also, it can be used to build a deduplication feature. Reference:https://coverage.readthedocs.io/en/7.4.1/api.html FAQ's How can coverage data for each request benefit developers? Obtaining coverage data for each request provides granular insights into the codebase's execution under various conditions, helps identify untested code paths, and can be used to build deduplication features for test cases. How can coverage data be obtained in a Python web server? Coverage data can be obtained using the coverage.py library, which provides both CLI and API for collecting coverage metrics programmatically. In a web server, coverage data can be captured using a middleware that wraps around the application logic and collects coverage information for each incoming request. What are some deduplication features for test cases based on coverage data? Deduplication features for test cases based on coverage data may include identifying and flagging duplicate tests by analyzing similar code paths, removing redundant tests, and optimizing test suites for better coverage and efficiency. In this blog, we will demonstrate how to get the coverage data for each incoming request on a Python web server built using any web framework. What Is Code Coverage? Code coverage is a metric used in software testing to measure the extent to which the source code of a program has been executed during testing. It indicates the percentage of code that has been covered by the test cases. Code coverage analysis helps developers understand how thoroughly their tests exercise the codebase. Code coverage tools are used to collect data on code execution during testing and generate reports showing the coverage metrics. These reports help developers identify areas of the code that are not adequately covered by tests, allowing them to write additional tests to improve coverage and increase confidence in the software's correctness and reliability. What Does It Mean to Get Coverage Data for Each Request? Obtaining coverage data for each request coming to a web server offers several benefits: Granular Insights: By capturing coverage data for each request, developers gain detailed insights into which parts of the codebase are executed in response to different types of requests. This level of granularity allows for a deeper understanding of the application's behavior under various conditions. Identifying Untested Code Paths: Coverage data helps identify areas of the code that are not adequately covered by tests. By analyzing coverage reports, developers can pinpoint specific code paths that need additional testing, ensuring comprehensive test coverage across the entire codebase. Building deduplication feature: coverage data for each e2e testcase can be analyzed to identify duplicate tests and remove them. Granular Insights: By capturing coverage data for each request, developers gain detailed insights into which parts of the codebase are executed in response to different types of requests. This level of granularity allows for a deeper understanding of the application's behavior under various conditions. Granular Insights : By capturing coverage data for each request, developers gain detailed insights into which parts of the codebase are executed in response to different types of requests. This level of granularity allows for a deeper understanding of the application's behavior under various conditions. Granular Insights Identifying Untested Code Paths: Coverage data helps identify areas of the code that are not adequately covered by tests. By analyzing coverage reports, developers can pinpoint specific code paths that need additional testing, ensuring comprehensive test coverage across the entire codebase. Identifying Untested Code Paths : Coverage data helps identify areas of the code that are not adequately covered by tests. By analyzing coverage reports, developers can pinpoint specific code paths that need additional testing, ensuring comprehensive test coverage across the entire codebase. Identifying Untested Code Paths Building deduplication feature: coverage data for each e2e testcase can be analyzed to identify duplicate tests and remove them. Building deduplication feature: coverage data for each e2e testcase can be analyzed to identify duplicate tests and remove them. Building deduplication feature: Obtaining Coverage Data To obtain the coverage data, we would be using the coverage.py library. coverage.py is mostly used through CLI. But it provides API to use it programmatically. We will define a middleware through which every incoming request would pass. In our "coverage" middleware, before passing control to other parts of our application, we will call the start function from the coverage library. Coverage measurement is only collected in functions called after start() function is invoked, so if this middleware is scheduled to run first, then coverage of other middleware would also be captured along with the main application code. start start() Once the application returns, then we will stop collecting coverage data. We can then fetch the data and further process it. The below is a code snippet for the coverage middleware which can be used in servers built using Flask web framework: import coverage

class CoverageMiddleware:
    def __init__(self, app):
        self.app = app

    def __call__(self, environ, start_response):
        cov = coverage.Coverage(cover_pylib=False)
        cov.start()
        response = self.app(environ, start_response)
        cov.stop()
        result = cov.get_data()
        Write(result)
        return response import coverage

class CoverageMiddleware:
    def __init__(self, app):
        self.app = app

    def __call__(self, environ, start_response):
        cov = coverage.Coverage(cover_pylib=False)
        cov.start()
        response = self.app(environ, start_response)
        cov.stop()
        result = cov.get_data()
        Write(result)
        return response Here, Write function writes the coverage data to a file, say dedupData.yaml, which can then be used to identify duplicate testcases in the e2e scenario. Here, Write function writes the coverage data to a file, say dedupData.yaml, which can then be used to identify duplicate testcases in the e2e scenario. Here is the modified sample Python application with middleware and writing logic in place: https://github.com/AkashKumar7902/samples-python/tree/v1.0.0/flask-mongo https://github.com/AkashKumar7902/samples-python/tree/v1.0.0/flask-mongo The repository includes test cases generated by Keploy, which can be replayed using the command keploy test -c "pythonapp.py" . Upon successful execution of this command, a dedupdata.yaml file will be generated. This file will contain details of the executed files, including the lines covered, for each test case. keploy test -c "pythonapp.py" dedupdata.yaml Here is a sample dedupdata.yaml: - id: test-1
  executedLinesByFile:
    /home/akash/Desktop/githubrepo/samples-python/flask-mongo/app.py:
    - 33
    - 34
    - 35
- id: test-2
  executedLinesByFile:
    /home/akash/Desktop/githubrepo/samples-python/flask-mongo/app.py:
    - 24
    - 23 - id: test-1
  executedLinesByFile:
    /home/akash/Desktop/githubrepo/samples-python/flask-mongo/app.py:
    - 33
    - 34
    - 35
- id: test-2
  executedLinesByFile:
    /home/akash/Desktop/githubrepo/samples-python/flask-mongo/app.py:
    - 24
    - 23 Using Coverage Data to Identify Duplicate Tests Earlier written dedupData.yaml which contains coverage data for each testcases, can be used to identify and flag duplicate testcases by analyzing similar codepaths. dedupData.yaml There are also multiple deduplication features for test cases based on coverage data for Keploy Cloud. Conclusion Conclusion This is how with very little code change you can collect coverage data for each incoming request and prioritize increasing coverage for the most frequent requests, and also, it can be used to build a deduplication feature. Reference: https://coverage.readthedocs.io/en/7.4.1/api.html Reference: Reference: https://coverage.readthedocs.io/en/7.4.1/api.html FAQ's How can coverage data for each request benefit developers? Obtaining coverage data for each request provides granular insights into the codebase's execution under various conditions, helps identify untested code paths, and can be used to build deduplication features for test cases. How can coverage data be obtained in a Python web server? Coverage data can be obtained using the coverage.py library, which provides both CLI and API for collecting coverage metrics programmatically. In a web server, coverage data can be captured using a middleware that wraps around the application logic and collects coverage information for each incoming request. coverage.py What are some deduplication features for test cases based on coverage data? Deduplication features for test cases based on coverage data may include identifying and flagging duplicate tests by analyzing similar code paths, removing redundant tests, and optimizing test suites for better coverage and efficiency.

Stories, News & Mentions about CODEOP

Codeop’s Stories on HackerNoon