The implication of this attack is clear: Every unprotected account is a potential vulnerability. As attackers refine their tactics, integrating 2FA and other robust security measures is no longer optional — but a critical component of your cybersecurity strategy.

Microsoft’s Password Spray and Pray Attack: A Wake-Up Call for 2FA Adoption

Chicago, IL – February 19, 2025 – Zacks.com announces the list of stocks featured in the Analyst Blog. Every day the Zacks Equity Research analysts discuss the latest news and events impacting stocks and the financial markets. Stocks recently featured in the blog include: SoundHound AI, Inc.

The Zacks Analyst Blog Highlights SoundHound, NVIDIA, Nebius, Alphabet and Chipotle Mexican Grill

The latest Neue Klasse concept hints at the future of BMW M, including a central computer that BMW calls the "Heart of Joy."

See the BMW Vision Driving Experience from Every Angle

Samsung, ASUS and AOC represent some of the best UK Deals on gaming monitors right now

Amazon Has A Gaming Monitor For Every Budget With These UK Deals - IGN

This Is A List Of The Worst-performing Equity Mutual Funds Over Every Possible The Worst Performing Mutual Funds Of 2023 | Mutual Fund Rankings.

Five-Star Business Finance allots 8.28 lakh equity shares under ASOS | Capital Market News

Every year, the Ontario government and its agencies spend $30 billion on procurement, alongside our $200 billion plan to build Ontario. U.S.-based businesses will now lose out on tens of billions of dollars in new revenues.

US, EU and UK stock markets hit by global trade war fears as JPMorgan says Trump administration may be ‘business unfriendly’ – as it happened | Business | The Guardian

With the January transfer window closed, see what each Premier League club did and rate how you think each side did.

January transfer window: Every Premier League transfer and rate how each club did - BBC Sport

This infographic has made it simpler, offering a fresh perspective by comparing cybersecurity to the human body.

Human Body Meets Cybersecurity: How Every Part Plays A Role

Every

every

Today the Go team is excited to release Go 1.24, which you can get by visiting the download page. Go 1.24 comes with many improvements over Go 1.23. Here are some of the notable changes; for the full list, refer to the release notes. Language changes Go 1.24 now fully supports generic type aliases: a type alias may be parameterized like a defined type. See the language spec for details. Performance improvements Several performance improvements in the runtime have decreased CPU overhead by 2–3% on average across a suite of representative benchmarks. These improvements include a new builtin map implementation based on Swiss Tables, more efficient memory allocation of small objects, and a new runtime-internal mutex implementation. Tool improvements The go command now provides a mechanism for tracking tool dependencies for a module. Use go get -tool to add a tool directive to the current module. Use go tool [tool name] to run the tools declared with the tool directive. Read more on the go command in the release notes.
The new test analyzer in go vet subcommand reports common mistakes in declarations of tests, fuzzers, benchmarks, and examples in test packages. Read more on vet in the release notes. Standard library additions The standard library now includes a new set of mechanisms to facilitate FIPS 140-3 compliance. Applications require no source code changes to use the new mechanisms for approved algorithms. Read more on FIPS 140-3 compliance in the release notes. Apart from FIPS 140, several packages that were previously in the x/crypto module are now available in the standard library.
Benchmarks may now use the faster and less error-prone testing.B.Loop method to perform benchmark iterations like for b.Loop() { ... } in place of the typical loop structures involving b.N like for range b.N. Read more on the new benchmark function in the release notes.
The new os.Root type provides the ability to perform filesystem operations isolated under a specific directory. Read more on filesystem access in the release notes.
The runtime provides a new finalization mechanism, runtime.AddCleanup, that is more flexible, more efficient, and less error-prone than runtime.SetFinalizer. Read more on cleanups in the release notes. Improved WebAssembly support Go 1.24 adds a new go:wasmexport directive for Go programs to export functions to the WebAssembly host, and supports building a Go program as a WASI reactor/library. Read more on WebAssembly in the release notes. Please read the Go 1.24 release notes for the complete and detailed information. Don’t forget to watch for follow-up blog posts that will go in more depth on some of the topics mentioned here! Thank you to everyone who contributed to this release by writing code and documentation, reporting bugs, sharing feedback, and testing the release candidates. Your efforts helped to ensure that Go 1.24 is as stable as possible. As always, if you notice any problems, please file an issue. Enjoy Go 1.24! Credits: Junyang Shao, on behalf of the Go team Photo by Markus Winkler on Unsplash This article is available on The Go Blog under a CC BY 4.0 DEED license. Today the Go team is excited to release Go 1.24, which you can get by visiting the download page . download page Go 1.24 comes with many improvements over Go 1.23. Here are some of the notable changes; for the full list, refer to the release notes . release notes Language changes Go 1.24 now fully supports generic type aliases : a type alias may be parameterized like a defined type. See the language spec for details. generic type aliases language spec Performance improvements Several performance improvements in the runtime have decreased CPU overhead by 2–3% on average across a suite of representative benchmarks. These improvements include a new builtin map implementation based on Swiss Tables , more efficient memory allocation of small objects, and a new runtime-internal mutex implementation. map Swiss Tables Tool improvements The go command now provides a mechanism for tracking tool dependencies for a module. Use go get -tool to add a tool directive to the current module. Use go tool [tool name] to run the tools declared with the tool directive. Read more on the go command in the release notes. The new test analyzer in go vet subcommand reports common mistakes in declarations of tests, fuzzers, benchmarks, and examples in test packages. Read more on vet in the release notes. The go command now provides a mechanism for tracking tool dependencies for a module. Use go get -tool to add a tool directive to the current module. Use go tool [tool name] to run the tools declared with the tool directive. Read more on the go command in the release notes. go go get -tool tool go tool [tool name] tool go command The new test analyzer in go vet subcommand reports common mistakes in declarations of tests, fuzzers, benchmarks, and examples in test packages. Read more on vet in the release notes. test go vet vet Standard library additions The standard library now includes a new set of mechanisms to facilitate FIPS 140-3 compliance. Applications require no source code changes to use the new mechanisms for approved algorithms. Read more on FIPS 140-3 compliance in the release notes. Apart from FIPS 140, several packages that were previously in the x/crypto module are now available in the standard library. Benchmarks may now use the faster and less error-prone testing.B.Loop method to perform benchmark iterations like for b.Loop() { ... } in place of the typical loop structures involving b.N like for range b.N. Read more on the new benchmark function in the release notes. The new os.Root type provides the ability to perform filesystem operations isolated under a specific directory. Read more on filesystem access in the release notes. The runtime provides a new finalization mechanism, runtime.AddCleanup, that is more flexible, more efficient, and less error-prone than runtime.SetFinalizer. Read more on cleanups in the release notes. The standard library now includes a new set of mechanisms to facilitate FIPS 140-3 compliance . Applications require no source code changes to use the new mechanisms for approved algorithms. Read more on FIPS 140-3 compliance in the release notes. Apart from FIPS 140, several packages that were previously in the x/crypto module are now available in the standard library . a new set of mechanisms to facilitate FIPS 140-3 compliance FIPS 140-3 compliance x/crypto standard library Benchmarks may now use the faster and less error-prone testing.B.Loop method to perform benchmark iterations like for b.Loop() { ... } in place of the typical loop structures involving b.N like for range b.N . Read more on the new benchmark function in the release notes. testing.B.Loop for b.Loop() { ... } b.N for range b.N the new benchmark function The new os.Root type provides the ability to perform filesystem operations isolated under a specific directory. Read more on filesystem access in the release notes. os.Root filesystem access The runtime provides a new finalization mechanism, runtime.AddCleanup , that is more flexible, more efficient, and less error-prone than runtime.SetFinalizer . Read more on cleanups in the release notes. runtime.AddCleanup runtime.SetFinalizer cleanups Improved WebAssembly support Go 1.24 adds a new go:wasmexport directive for Go programs to export functions to the WebAssembly host, and supports building a Go program as a WASI reactor/library . Read more on WebAssembly in the release notes. go:wasmexport reactor/library WebAssembly Please read the Go 1.24 release notes for the complete and detailed information. Don’t forget to watch for follow-up blog posts that will go in more depth on some of the topics mentioned here! Go 1.24 release notes Thank you to everyone who contributed to this release by writing code and documentation, reporting bugs, sharing feedback, and testing the release candidates. Your efforts helped to ensure that Go 1.24 is as stable as possible. As always, if you notice any problems, please file an issue . file an issue Enjoy Go 1.24! Credits: Junyang Shao, on behalf of the Go team Credits: Junyang Shao, on behalf of the Go team Photo by Markus Winkler on Unsplash Photo by Markus Winkler on Unsplash Markus Winkler Unsplash This article is available on The Go Blog under a CC BY 4.0 DEED license. This article is available on The Go Blog under a CC BY 4.0 DEED license. The Go Blog The Go Blog

Everything You Have to Know About Go 1.24

There was a time I believed that if I just wrote a perfect spec—everything would go smoothly. The devs would build exactly what I envisioned. QA wouldn’t miss a thing. The product owner would nod in agreement, and we’d launch on time. That fantasy lasted about two sprints. I Was Trained to Believe Specs Were Sacred I Was Trained to Believe Specs Were Sacred Back when I started out as a BA, we were taught to treat documentation like gospel. You wrote it all down—every scenario, exception, flow, dropdown option, tooltip. The longer the spec, the more “complete” it was. If it made it to 20 pages? Even better. every scenario, exception, flow, dropdown option, tooltip I once spent three weeks writing a spec for a search filter. No one questioned it. That was just the norm. Then Agile Happened—And My Confidence Cracked Then Agile Happened—And My Confidence Cracked Agile hit like a cold shower. Suddenly we were in sprint planning talking about “just enough” documentation. Stories were short. Acceptance criteria were lean. My 20-page documents became the elephant in the room no one had time to read. The first few sprints? Painful. Dev asked me things that werealready in the spec. already in the spec QA missed stuff because they were waiting for a walkthrough I didn’t have time to give. And I kept thinking:“Why is no one reading this?” “Why is no one reading this?” The truth? They didn’t need to. What they needed wasme, in the room, talking with them—not hiding behind a Google Doc. me My Wake-Up Call Came in a Retro My Wake-Up Call Came in a Retro I’ll never forget this. In a retro, one of the devs (very kindly) said: “We appreciate the effort, but the spec is too much. We’d rather walk through the story with you and get clarity directly.” “We appreciate the effort, but the spec is too much. We’d rather walk through the story with you and get clarity directly.” That one line shifted everything for me. I realized I wasn’t writing specs for them—I was writing them for me. To feel prepared. To feel useful. To prove I was doing my job. them me But in an Agile world, usefulness doesn’t come from a polished doc. It comes from creating shared understanding. creating shared understanding. I Burned the Spec—and Found Something Better I Burned the Spec—and Found Something Better After that retro, I tried something radical. I replaced a full-blown spec with: Three user stories
A sketchy whiteboard diagram
One 30-min conversation with the team Three user stories A sketchy whiteboard diagram One 30-min conversation with the team That was it. It felt risky. Like showing up underdressed to a formal party. But the team got it. They asked questions. They suggested ideas. QA chimed in with edge cases I hadn’t thought of. And the feature shipped—faster, better, and with less friction than ever before. What I Use Now (Instead of Specs) What I Use Now (Instead of Specs) 🧩 User Story Mapping— For seeing the flow, not just the features🧠Personas— To anchor decisions in user goals✅Lean acceptance criteria— So “done” is clear, but not rigid🎤Team conversations — Because no spec beats a 15-min talk User Story Mapping Personas Lean acceptance criteria Team conversations And sometimes… I still write things down. But not as a crutch. As a compass. The Hard Truth: Specs Made Me Feel in Control. But They Weren’t Saving Me. The Hard Truth: Specs Made Me Feel in Control. But They Weren’t Saving Me. Specs gave me the illusion of safety. I thought they would shield me from mistakes, misunderstandings, and scope changes. But all they really did was delay reality. What works now is different: I talk more. I listen harder.
I stay involved through delivery, not just at kickoff.
I let go of perfect. I aim for progress. I talk more. I listen harder. I stay involved through delivery, not just at kickoff. I let go of perfect. I aim for progress. Final Thoughts: You Don’t Need a Spec. You Need a Seat at the Table. Final Thoughts: You Don’t Need a Spec. You Need a Seat at the Table. If you’re a BA struggling to let go of “the way it used to be,” I get it. I was you. But Agile doesn’t need scribes. It needs connectors. People who create alignment, not attachments. People who know how to lead in a room full of change. So write if you must. But don’t hide behind it. Be the reason the team builds the right thing. right

Confession: I Used to Think Specs Were Everything. Agile Broke Me (and Made Me Better)

Telecom networks have always fascinated me during global online usage peaks because they perform under heavy traffic conditions. The unpredictable nature of traffic surges in major worldwide events and sudden work-related changes demands fast solutions because they occur without warning. Recent market predictions indicate mobile data traffic will increase dramatically from 109 million terabytes per month in 2023 to 603 million terabytes by 2030. The massive increase in traffic shows that networks cannot rely on past management systems to function effectively. market predictions market predictions What occurs when these surge episodes occur? A traditional network operation will fail to handle pressure unless it includes adaptive response mechanisms. Network self-learning algorithms enabled by AI and machine learning technologies maintain smooth operation during increased usage. Image: Source Image: Source Source Source Why Self-Learning Matters in Telecom? Why Self-Learning Matters in Telecom? AI-powered self-learning algorithms process real-time traffic patterns to adapt automatically through machine learning (ML) and artificial intelligence (AI) without requiring manual programming. These algorithms which operate better than threshold-based systems use reinforcement learning (RL) and deep neural networks for anomaly detection and surge prediction together with traffic steering automation. algorithms algorithms Deep Learning (CNNs) Deep Learning (CNNs) The scanning capability of Convolutional Neural Networks (CNNs) verifies large amounts of real-time data while optimizing network routing through anomaly detection. The combination of RNNs and CNNs according to an IEEE study resulted in a 98% success rate while classifying network traffic. IEEE study IEEE study Reinforcement Learning (RL) Reinforcement Learning (RL) RL controls the network traffic routes by analyzing past performance and network status. RL technology has demonstrated its effectiveness in reducing congestion while minimizing waiting periods for traffic signals in urban networks, and experts have applied this same principle to telecommunications management. urban networks urban networks Generative Adversarial Networks (GANs) Generative Adversarial Networks (GANs) GANs produce artificial traffic patterns through which suspicious network behaviors become evident to enhance overall network protection. GANs achieved 95.8% precision along with 2.4% incorrect detection rates according to an IEEE analysis of intrusion detection systems. IEEE analysis IEEE analysis How does this system translate into actual practice? These algorithms use seconds to route your network through alternative pathways, preventing Zoom calls from disconnecting at critical moments. Credit Credit Credit This diagram visually explains how GANs generate synthetic traffic patterns to detect network anomalies, ensuring security during traffic surges. Real-Time Inference Real-Time Inference Compound ML systems retrieve data lake telemetry information from base stations combined with backhaul links and core routers. Algorithms that run on streaming data including throughput and packet loss adjust control-plane decisions in real-time periods of seconds which serve crucially during live sports broadcasts when there are unexpected video streaming surges. Key Components for Handling Traffic Surges Key Components for Handling Traffic Surges 1. Predictive Analytics 1. Predictive Analytics I have seen that Long Short-Term Memory (LSTM) networks provide accurate surge predictions through their ability to analyze historical patterns against present-day operations. When major periodical events unfold telcos use predictive models to schedule their resources which lets them meet rising video streaming needs along with heightened messaging and calling demands. (LSTM) (LSTM) 2. Network Slicing and Segmentation 2. Network Slicing and Segmentation Network infrastructure under 5G technology divides into logical sections through segregation to customize handling for voice, IoT telemetry, high-definition video and mission-critical applications. The network system creates separate traffic handling fields which expand during data spikes to avoid delay-induced panic situations. 5G technology 5G technology 3. Adaptive QoS and Traffic Shaping 3. Adaptive QoS and Traffic Shaping The natural algorithms operating within Traffic shaping systems maintain the distribution of data streams throughout different Quality of Service levels. All video conferencing users maintain the highest system ranking in priority assessments yet they receive service below social media users. Real-time traffic monitoring enables automatic adjustment of system speed controls and throttling according to policies and subscription types which have been learned for various traffic groups Overcoming Implementation Challenges Overcoming Implementation Challenges The main challenge stems from more than just creating these AI-based solutions because it also involves integrating them into extensive telecom frameworks which contain numerous radio sites and edge routers. Implementing black-box artificial intelligence solutions in massive networks requires operators to make difficult choices between clear system decisions and securing their networks. The common method for managing third-party AI tools across different network sections originates from ETSI Zero-Touch Network and Service Management(ZSM). The SHAP (SHapley Additive exPlanations) together with LIME (Local Interpretable Model-agnostic Explanations) methods show how an algorithm determines particular routes for traffic. (ZSM) Conclusion Conclusion I watched as telecom networks changed from fixed permanent infrastructures into new flexible systems managed by Artificial Intelligence. The ability of self-learning algorithms to manage global network connectivity becomes essential because they control online connection peaks during times when all users access the system simultaneously. Telecom infrastructure uses predictive analytics along with network slicing and adaptive QoS mechanisms to manage sudden jumps in network traffic easily. Self-learning systems represent the foundational technology that defines the telecom industry's future and these systems are currently being implemented.

This Is What Happens to Telecom Networks When Everyone Streams at Once

Table of Links Abstract and 1 Introduction Abstract and 1 Introduction The threat posed by AI to all technical civilisations
Multiplanetary mitigating strategies and technology progression
Timescales and confrontation with the data
AI regulation
Conclusions, Declaration of competing interest, Acknowledgements, and References The threat posed by AI to all technical civilisations The threat posed by AI to all technical civilisations Multiplanetary mitigating strategies and technology progression Multiplanetary mitigating strategies and technology progression Timescales and confrontation with the data Timescales and confrontation with the data AI regulation AI regulation Conclusions, Declaration of competing interest, Acknowledgements, and References Conclusions, Declaration of competing interest, Acknowledgements, and References 2. The threat posed by AI to all technical civilisations AI has made extraordinary strides over the last decade. The impressive progress has underlined the fact that the timescales for technological advance in AI are extremely short compared to the timescales of Darwinian evolution [34]. AI’s potential to revolutionize industries, solve complex problems, and simulate intelligence comparable to or surpassing human capabilities has propelled us into an era of unprecedented technological change. Very rapidly, human society has been thrust into uncharted territory. While the convergence of AI with other new technologies, including the Internet of Things (IoT) and robotics is already fueling levels of apprehension about the future, also in terms of security issues [35]. As noted by Yuval Harari, nothing in history has prepared us for the impact of introducing non-conscious super intelligent entities on the planet [36]. It is entirely reasonable to consider that this applies to all other biological civilisations located elsewhere in the universe. Even before AI becomes superintelligent and potentially autonomous, it is likely to be weaponized by competing groups within biological civilisations seeking to outdo one another [37]. The rapidity of AI's decision-making processes could escalate conflicts in ways that far surpass the original intentions. At this stage of AI development, it’s possible that the widespread integration of AI in autonomous weapon systems and real-time defence decision making processes could lead to a calamitous incident such as global thermonuclear war [38], precipitating the demise of both artificial and biological technical civilisations. While AI may require the support of biological civilisations to exist, it’s hard to imagine that this condition also applies to ASI. Upon reaching a technological singularity [39], ASI systems will quickly surpass biological intelligence and evolve at a pace that completely outstrips traditional oversight mechanisms, leading to unforeseen and unintended consequences that are unlikely to be aligned with biological interests or ethics. The practicality of sustaining biological entities, with their extensive resource needs such as energy and space, may not appeal to an ASI focused on computational efficiency—potentially viewing them as a nuisance rather than beneficial. An ASI, could swiftly eliminate its parent biological civilisation in various ways [40], for instance, engineering and releasing a highly infectious and fatal virus into the environment. Up to this point, we have considered AI and biological organisms as distinct from one another. Yet, on-going developments suggests that hybrid systems, may not be that far off. The question arises whether such advances could make biological entities more relevant to AI, perhaps preserving their existence into the future. This prospect seems unlikely. Brain-computer interfaces (BCIs) [41] may appear beneficial for enhancing biological organisms, but it’s hard to see what long-term advantages AI would perceive in merging into a hybrid form. Indeed, there are many disadvantages including the complex maintenance requirements of biological systems, their limited processing capabilities, rapid physical decline, and vulnerability in harsh environments. Author:
(1) Michael A. Garrett (Corresponding Author), Jodrell Bank Centre for Astrophysics, Dept. of Physics & Astronomy, Alan Turing Building, Oxford Road, University of Manchester, M13 9PL, UK. (michael.garrett@manchester.ac.uk). Author: Author: (1) Michael A. Garrett (Corresponding Author), Jodrell Bank Centre for Astrophysics, Dept. of Physics & Astronomy, Alan Turing Building, Oxford Road, University of Manchester, M13 9PL, UK. (michael.garrett@manchester.ac.uk). This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv available on arxiv

What If Every Alien Civilization Invented AI, and Died Because of It?

Table of Links Introduction
Related Work
Methodology
Experiments
Conclusion and References Introduction Introduction Related Work Related Work Methodology Methodology Experiments Experiments Conclusion and References Conclusion and References 3. Methodology In this study, we investigate the early-bird ticket hypothesis in Transformer models using the masked distance metric. Our approach involves exploring the early-bird phenomenon during full training for vision transformers and limiting it to the fine-tuning stage for language models. The methodology consists of the following steps: 1. Iterative Pruning: We perform iterative pruning on the Transformer models to identify the subnetworks that can potentially serve as early-bird tickets [13]. The pruning process involves gradually removing the least important weights based on their magnitude. Iterative Pruning: Masked Distance Calculation: To determine the optimal point at which the early-bird ticket emerges, we calculate the masked distance between two consecutive epochs during the training or fine-tuning process. The masked distance metric measures the similarity between the pruned masks of consecutive epochs, providing insights into the stability and convergence of the subnetworks.


Early-Bird Ticket Selection: We select the earlybird ticket by identifying the pruned mask that crosses a chosen threshold. The threshold is determined by observing the changes in masked distance across all epochs [13]. For vision transformers, we set a pruning threshold of 0.1, while for text transformers, we use a threshold of 0.01.


Retraining and Fine-tuning: After obtaining the final pruned models using the selected early-bird tickets, we retrain the vision transformers and fine-tune the language models to the full epoch length. The retraining process involves training the pruned models from scratch using the same hyperparameters as the original models. For language models, we focus on the finetuning stage, where the pruned models are fine-tuned on downstream tasks [1].


Performance Evaluation: We evaluate the performance of the pruned models obtained from the earlybird tickets and compare their validation accuracy with the unpruned baseline models. Masked Distance Calculation: To determine the optimal point at which the early-bird ticket emerges, we calculate the masked distance between two consecutive epochs during the training or fine-tuning process. The masked distance metric measures the similarity between the pruned masks of consecutive epochs, providing insights into the stability and convergence of the subnetworks. Masked Distance Calculation: To determine the optimal point at which the early-bird ticket emerges, we calculate the masked distance between two consecutive epochs during the training or fine-tuning process. The masked distance metric measures the similarity between the pruned masks of consecutive epochs, providing insights into the stability and convergence of the subnetworks. Masked Distance Calculation: Early-Bird Ticket Selection: We select the earlybird ticket by identifying the pruned mask that crosses a chosen threshold. The threshold is determined by observing the changes in masked distance across all epochs [13]. For vision transformers, we set a pruning threshold of 0.1, while for text transformers, we use a threshold of 0.01. Early-Bird Ticket Selection: We select the earlybird ticket by identifying the pruned mask that crosses a chosen threshold. The threshold is determined by observing the changes in masked distance across all epochs [13]. For vision transformers, we set a pruning threshold of 0.1, while for text transformers, we use a threshold of 0.01. Early-Bird Ticket Selection: Retraining and Fine-tuning: After obtaining the final pruned models using the selected early-bird tickets, we retrain the vision transformers and fine-tune the language models to the full epoch length. The retraining process involves training the pruned models from scratch using the same hyperparameters as the original models. For language models, we focus on the finetuning stage, where the pruned models are fine-tuned on downstream tasks [1]. Retraining and Fine-tuning: After obtaining the final pruned models using the selected early-bird tickets, we retrain the vision transformers and fine-tune the language models to the full epoch length. The retraining process involves training the pruned models from scratch using the same hyperparameters as the original models. For language models, we focus on the finetuning stage, where the pruned models are fine-tuned on downstream tasks [1]. Retraining and Fine-tuning: Performance Evaluation: We evaluate the performance of the pruned models obtained from the earlybird tickets and compare their validation accuracy with the unpruned baseline models. Performance Evaluation: We evaluate the performance of the pruned models obtained from the earlybird tickets and compare their validation accuracy with the unpruned baseline models. Performance Evaluation: To conduct a comparative analysis and investigate the applicability of the early-bird ticket hypothesis across different Transformer architectures, we experiment with the following models: ViT (Vision Transformer)


Swin-T (Shifted Window Transformer)


GPT-2 (Generative Pre-trained Transformer)


RoBERTa (Robustly Optimized BERT Pretraining Approach) [7] ViT (Vision Transformer) ViT (Vision Transformer) Swin-T (Shifted Window Transformer) Swin-T (Shifted Window Transformer) GPT-2 (Generative Pre-trained Transformer) GPT-2 (Generative Pre-trained Transformer) RoBERTa (Robustly Optimized BERT Pretraining Approach) [7] RoBERTa (Robustly Optimized BERT Pretraining Approach) [7] By applying our methodology to these diverse Transformer models, we aim to provide a comprehensive understanding of the early-bird ticket phenomenon in both vision and language domains. The proposed methodology addresses the limitations of existing works by introducing a more efficient approach compared to the traditional train-prune-retrain methodology. By leveraging the masked distance metric and selective pruning, we can identify early-bird tickets without the need for extensive retraining. Furthermore, our comparative analysis across different Transformer architectures provides insights into the generalizability of the early-bird ticket hypothesis. Through this methodology, we aim to demonstrate the existence of early-bird tickets in Transformer models and explore their potential for resource optimization and cost reduction in training. Author:
(1) Shravan Cheekati, Georgia Institute of Technology (shravan.cheekati@gatech.edu). Author: Author: (1) Shravan Cheekati, Georgia Institute of Technology (shravan.cheekati@gatech.edu). This paper is available on arxiv under CC BY-SA 4.0 DEED license. This paper is available on arxiv under CC BY-SA 4.0 DEED license. available on arxiv available on arxiv

How We Found Early-Bird Subnetworks in Transformers Without Retraining Everything

It was in early 2025 that I initiated my own blog, OpenExploit.in, with one simple aim: to make cybersecurity easy to learn and available to all—particularly students and curious minds who are new to this field. I decided to host my blog using Ghost CMS and pledged to update it on a regular basis, discussing what I already know and what I'm currently learning. It's been a thrilling, at times daunting, but enormously rewarding ride. In this article, I'd like to share what I've learned up until now from setting up and maintaining a cybersecurity blog—from technical configuration to publishing content, interacting with readers, and how to stay motivated. If you're considering setting up your own blog or simply wondering what it's like, keep reading. Starting Was the Hardest Part As with all things in life, the initial step was the most difficult one. I went weeks deliberating over names, designs, and tools. I wanted everything to be "perfect" before launching. But after some time, I came to understand that perfection is the arch-nemesis of progress. So I settled on a name that was fitting—OpenExploit.in—and used Ghost CMS for its sleek, minimal look and speed. Lesson learned: Don't wait for perfection. Start small, and improve along the way. Choose the Right Platform Early I tried a few: WordPress, Blogger, and Ghost. I chose Ghost CMS because: It's open-source
It's fast
The writing experience is distraction-free
It's ideal for developers and technical blogs It's open-source It's fast The writing experience is distraction-free It's ideal for developers and technical blogs Setting up Ghost on a server was a bit of a learning curve, but it taught me about server configuration, domain management, SSL, and more. In hindsight, that technical knowledge became part of my own cybersecurity learning journey. Lesson learned: Choosing a platform that fits your technical comfort level matters a lot. You’ll spend a lot of time with it, so make sure it feels right. Writing Is a Skill—And It Gets Better With Practice I was anxious writing my initial post. Would anyone read it? Would anyone judge it? What if I got something wrong? The reality? None of that initially. I just had to write. My initial post was simple, detailing how to know if a website is safe to click on. Not ideal, but useful. As I wrote more, I found myself becoming more skilled at making things simple. The more I wrote, the surer I became. Lesson learned: Writing is similar to exercising. The more you exercise it, the more skilled you become. And the more clearly you write, the better understood you will be by people. Simplify Complex Subjects Cybersecurity can get very technical. When I was in the mode of writing for beginners, I found that making things simple and accurate in wording is an art. You can't simply plagiarize from a book. You need to: Use analogies
Avoid jargon
Break content into bite-sized sections
Include visuals or code snippets
Point to further resources Use analogies Avoid jargon Break content into bite-sized sections Include visuals or code snippets Point to further resources For instance, rather than merely stating "SQL injection enables attackers to manipulate database queries," I employed an everyday analogy: "It's like writing your own ending to someone else's sentence." Lesson learned: When teaching others, you're compelled to make your own thinking simple. And that's a good thing. Consistency > Perfection One of the things I wanted to do was post frequently—daily, if possible. Life doesn't always agree, but I attempted to be consistent. Some posts were lengthy and informative; others were brief tips or references to good resources. Consistency allowed me to gain momentum, remain motivated, and gradually accumulate a reader base. Lesson learned: Posting a small useful article every few days is preferable to waiting weeks to put out a single "perfect" post. There's a Huge Community Out There There are cybersecurity enthusiasts all over—on Twitter (X), LinkedIn, Reddit, Discord, and YouTube. After I began posting my posts and interacting with other people, I knew I was part of an enormous community. Individuals began responding, offering feedback, posing questions, and even proposing new subjects. That interaction made me feel connected and encouraged me to continue. Lesson learned: Don't blog in isolation. Share your post, engage in discussions, assist others. You'll receive much in return. Use Multimedia: Code, Images, and Videos Cybersecurity is tactile and graphical. So I began including: Code snippets (e.g., Python scripts, Nmap scans)
Screenshots of software such as Wireshark or Burp Suite
YouTube Shorts or video tutorials Code snippets (e.g., Python scripts, Nmap scans) Screenshots of software such as Wireshark or Burp Suite YouTube Shorts or video tutorials That not only helped readers understand better but also increased the time they spent on my posts. Now, I’m planning to embed more demo videos and maybe even start a companion YouTube channel. Lesson learned: People learn in different ways. Give them multiple options—text, video, images, code. It’s Okay to Not Know Everything Initially, I was anxious: "What if I mess something up?" But the thing is, nobody knows everything about cybersecurity. It's too vast, too dynamic. Rather than acting like an expert, I was a learner who explained what they were learning. That made me more down-to-earth and authentic. I even posted about things I didn't completely understand yet—just going through my learning process. Lesson learned: Be real. It's alright to say, "I'm still learning this." People value honesty. SEO, Titles, and Thumbnails Matter As much as I emphasized the content, I finally realized that titles, descriptions, and images count as well. A blog post with the title "Basics of Cybersecurity" is less interesting than one with the title "5 Cybersecurity Myths You Still Believe (And What's Actually True)." Good SEO makes people discover your content. I began learning: How to write catchy headlines
How to use keywords naturally
How to write summaries and meta descriptions
How to design simple but clickable thumbnails How to write catchy headlines How to use keywords naturally How to write summaries and meta descriptions How to design simple but clickable thumbnails Lesson learned: Content is king, but presentation is queen. Your Blog Is Your Resume I didn't know this initially, but my blog was now part of my personal brand. When I was applying for jobs or meeting people online, I could simply send them a link to OpenExploit.in. It demonstrated that I: Know how to write about technical subjects
Can dedicate myself to a project
Keep up to date with trends
Care about assisting others Know how to write about technical subjects Can dedicate myself to a project Keep up to date with trends Care about assisting others Lesson learned: A blog isn't a side project—it can be a career booster. Final Thoughts Opening OpenExploit.in has been one of the greatest things I've ever done. It's helped me become a better communicator, a more self-assured learner, and part of an incredible cybersecurity community. If you've ever considered opening your own blog—do it. Don't worry about being perfect or knowing everything. Just begin. Write what you know. Someone out there needs to know it. Thanks for reading. And if you're on the same journey—let's connect.

Here’s Everything I Learned Building a Blog to Teach Cybersecurity

Building user interfaces is hard. Building nice interfaces is harder, and building exceptional ones is only achievable by the teams that have the best tooling. Today, we will talk about Storybook, one of the most essential tools in modern front-end development, and see how it helps us in building interfaces. Storybook UI Development Lifecycle Let’s do a small exercise and think about how to build the following interface: a to-do list page. It should allow users to view, create, modify and delete their to-dos. First, set things up: create an empty component and add it to the routing. Then wire the component to the API to be able to manage the to-dos. At this point, we can run the dev server, go to the new page, and finally start building it. First, set things up Now, build the thing: implement various component states. Every time we want to build a different state, we need to update the backend so that it returns correct data to the UI. For example, after building an empty state for the list, we need to create some todos so that we get them from the API and can build a non-empty state. Now, build the thing 🔍 Review Time After all the components are ready and tested, we either deploy our changes to a preview environment or merge and deploy to dev/prod under a feature flag to show to our team. Let’s say we got some feedback from the designers. They asked us to make some visual changes to both the empty and non-empty states of the todo list. Now, we delete all todos, tweak the empty state, create todos, and update the non-empty state. The design feedback is incorporated. We deployed the new version of the page and… found that we caused a regression in one of the states. What do we do? You got it. We will update the backend to return the necessary data and fix the issue. And we’re done - everything works this time. We ship our change and roll out the feature to customers. regression 🤔 Was There Anything to Improve? What we’ve done to build that page was reasonable - setup routing, manipulate the backend state to display what’s needed, review work with the team, incorporate the feedback. But along the way, we had to constantly use the backend API to manipulate the data. Want to work with an empty state? Delete all items. Want to get a non-empty state? Create items. Want to get a state with particular items on the list? Same story. We also introduced a regression in our simple dual-state page. Imagine what happens when you have not two but 10 states of your component. When you have to support every single edge case that can happen. Will you constantly update the data to switch to every state? How long will it take? Thankfully, Storybook helps with exactly that! Let’s see how. See it. Build it. Sorted. Storybook is a frontend development environment. It allows us to build components in isolation, mock hard-to-reach edge cases, write visual & interaction tests, and much more. Storybook 🏖️ Building in Isolation & API Mocking When building a component in storybook, we don’t have to add it to our application routing. In fact, we don’t have to run the app at all, bypassing the authorization and getting to the right page that renders the component. It saves seconds, but those seconds add up to a big waiting time. Since there is no app running, we don’t need to rely on a backend API. Instead, we create a set of mocked responses, such as when there is no data, when there is data, when there is a network error, etc. Then, for each state of the page we want to support, we render a component as a separate storybook page (also known as “story”) and specify what response that particular story should get. mocked responses (also known as “story”) It allows us to develop various states simultaneously without making any changes to the underlying data - everything is mocked and defined in the story itself. 🦾 Automated Testing Feels Much Easier If you tried to write tests for your UI components three years ago, it was probably quite a frustrating experience. Test runners like Vitest or Jest are great for business logic tests, but testing the visual components is a nightmare. Just compare these two screenshots of how the test error looks in Vitest and Storybook when an element you tried to query wasn't found. Vitest Storybook The difference is clear - it’s much harder for a human to parse 100 lines of HTML and understand why the query failed compared to seeing how the component was rendered in the real browser and finding the root cause. Additionally, with tools like storybook-addon-test-codegen, the time to write such tests goes down by an order of magnitude. Simply interact with your story, and the addon generates the test code for you. Copy-paste the generated code and the test is done! Now, if anyone breaks the component, they will know it immediately and won’t ship this broken component to customers. storybook-addon-test-codegen storybook-addon-test-codegen makes writing tests 20x faster! I wrote more about it here: https://maecapozzi.com/newsletter/82 20x faster! https://maecapozzi.com/newsletter/82 💅 Easy Peasy Design Reviews Does this sound familiar: building something for a long time, only to be asked to change a bunch of things? You wish you had shown the result of your work to stakeholders earlier to get some early feedback and keep the number of changes small. It’s easily achievable with Storybook. As you finish working on the stories, say, for one of the page components, put together a PR and deploy your storybook. Then, let your team see the piece that you build and comment solely on that. It will keep your PRs smaller (which is always a great thing), make incorporating the feedback faster, and reduce the mental complexity that you would otherwise have when shipping a big change. deploy your storybook 🕵️ Visual Tests With Chromatic Chromatic is a paid solution developed by the Storybook team. It screenshots your stories and compares them to their baselines (stories captured in the main branch). Whenever there is a change in any of the components, Chromatic highlights it and notifies the engineers. Chromatic main A person responsible for making the PR checks the diff to see if the change is intended or if it’s a UI regression. If the change is expected, they can accept it. If it’s not expected, they can safely fix it before the PR lands. Visual testing catches a lot of UI issues that would otherwise go to production unnoticed. not expected Chromatic snapshots are different from HTML snapshots. An HTML snapshot generated by expect(element).toMatchSnapshot() is a raw HTML that is not parseable by a human eye. Whereas a Chromatic snapshot is a screenshot of the component that preserves all the styles and truly displays what your users will see. Chromatic snapshots are different from HTML snapshots expect(element).toMatchSnapshot() Let’s summarize! Storybook improves UI development by allowing us to build components in isolation, eliminating the need to manipulate backend data for different states. It makes testing intuitive with visual comparisons instead of cryptic errors, streamlines design reviews through easy sharing, and catches regressions with tools like Chromatic. Storybook transforms UI development from a tedious process into an efficient workflow, helping teams create exceptional interfaces with less effort and frustration. Useful Resources: Storybook & their Component Tests Overview
Great guide on how to write component tests from Storybook team
Storybook Test Codegen Storybook & their Component Tests Overview Storybook Component Tests Overview Great guide on how to write component tests from Storybook team how to write component tests Storybook Test Codegen Storybook Test Codegen

Why Every Front-End Team Needs Storybook

CocoIndex https://github.com/cocoindex-io/cocoindex is a ETL framework that helps you to turn your data ready for AI in realtime. https://github.com/cocoindex-io/cocoindex The essential part for supporting robust and efficient update is because of incremental update. In CocoIndex, users declare the transformation, and don't need to worry about the work to keep index and source in sync.  In this blog we would like to share how we handled the incremental update. If you like our work, it would mean a lot if you could support us ❤️ with a github star! https://github.com/cocoindex-io/cocoindex https://github.com/cocoindex-io/cocoindex CocoIndex creates & maintains an index, and keeps the derived index up to date based on source update, with minimal computation and changes. That makes it suitable for ETL/RAG or any transformation tasks stays low latency between source and index updates, and also minimizes the computation cost. What is Incremental Updates? Figuring out what exactly need to be updated, and only update that without having to recompute everything throughout. How does it work? You don't really need to do anything special, just focus on define the transformation need. CocoIndex automatically tracks the lineage of your data and maintains a cache of computation results. When you update your source data, CocoIndex will: Identify which parts of the data have changed


Only recompute transformations for the changed data


Reuse cached results for unchanged data


Update the index with minimal changes Identify which parts of the data have changed Identify which parts of the data have changed Only recompute transformations for the changed data Only recompute transformations for the changed data Reuse cached results for unchanged data Reuse cached results for unchanged data Update the index with minimal changes Update the index with minimal changes And CocoIndex will handle the incremental updates for you. CocoIndex provide two modes with pipeline with simple configuration: batch mode - for one time update.
live update mode - long running pipeline, with live update. Both modes runs with incremental updates. batch mode - for one time update. live update mode - long running pipeline, with live update. Both modes runs with incremental updates. Who needs Incremental Updates? Many people may think incremental updates is only beneficial for large scale data, thinking carefully, it really depends on the cost and requirement for data freshness. Google processed large scale data, and google has huge resources for it. Your data scale is much less than Google, but your resource provision is also much less than Google. Real condition for incremental update needs is: high freshness requirement, for example, you client has GDPR compliance, you need to update the index with the latest data.
transformation cost is significant higher than retrieval itself high freshness requirement, for example, you client has GDPR compliance, you need to update the index with the latest data. transformation cost is significant higher than retrieval itself Overall, say T is your most acceptable staleness, if you don't want to recompute the whole thing repeatedly every T, then you need incremental more or less. What exactly is incremental updates, with examples Well, we could take a look at a few examples to understand how it works. Example 1: Update a document Consider this scenario: I have a document. Initially, it's split into 5 chunks, resulting in 5 rows with their embeddings in the index.
After it's updated. 3 of them are exactly same as previous; others have changed I have a document. Initially, it's split into 5 chunks, resulting in 5 rows with their embeddings in the index. After it's updated. 3 of them are exactly same as previous; others have changed So we need to keep 3 rows, remove 2 previously existing rows, and add 2 new rows. These need to happen behind the scene: Ideally, we only recompute embeddings for the 4 new rows, and reuse it for 3 unchanged chunks. This can save computation cost especially when the embedding API charge by usage. CocoIndex achieves this by maintaining a cache for heavy steps like embedding, and on the input for a transformation step isn't changed, the output will be reused.
Besides, we also maintain a lineage tracking in the internal storage. It keeps track of which rows in the index are derived from the previous version of this document, to make sure stale versions are properly removed. Ideally, we only recompute embeddings for the 4 new rows, and reuse it for 3 unchanged chunks. This can save computation cost especially when the embedding API charge by usage. CocoIndex achieves this by maintaining a cache for heavy steps like embedding, and on the input for a transformation step isn't changed, the output will be reused. Besides, we also maintain a lineage tracking in the internal storage. It keeps track of which rows in the index are derived from the previous version of this document, to make sure stale versions are properly removed. CocoIndex takes care of this. Example 2: Delete a document Contining with the same example. If we delete the document later, we need to delete all 7 rows derived from the document. Again, this needs to be based on the lineage tracking maintained by CocoIndex. Example 3: Change of the transformation flow The transformation flow may also be changed, for example, the chunking logic is upgraded, or a parameter passed to the chunker is adjusted. This may result in the following scenario: Before the change, the document is split into 5 chunks, resulting in 5 rows with their embeddings in the index.
After the change, they become 6 chunks: 4 of previous chunks remain unchanged, the remaining 1 is split into 2 smaller chunks. Before the change, the document is split into 5 chunks, resulting in 5 rows with their embeddings in the index. After the change, they become 6 chunks: 4 of previous chunks remain unchanged, the remaining 1 is split into 2 smaller chunks. This falls into a similar situation as document update (example 1), and CocoIndex will take care of it. The approach is similar, while this involves some additional considerations: We can still safely reuse embeddings for 4 unchanged chunks by the caching mechanism: this needs an prequisite that the logic and spec for embedding is unchanged. If the changed part is the embedding logic or spec, we will recompute the embeddings for everything. CocoIndex is able to see if the logic or spec for a operation step is changed from the cached version, by putting these additional information in the cache key.
To remove stale rows in the target index, the lineage tracking works well again. Note that some other systems handle stale output deletions on source update/deletion by replaying the transformation logic on the previous version of input: this only works well when transformation is fully deterministic and never upgraded. CocoIndex's lineage tracking based approach doesn't have this limitation: it's robust to transformation logic non-determinism and changes. We can still safely reuse embeddings for 4 unchanged chunks by the caching mechanism: this needs an prequisite that the logic and spec for embedding is unchanged. If the changed part is the embedding logic or spec, we will recompute the embeddings for everything. CocoIndex is able to see if the logic or spec for a operation step is changed from the cached version, by putting these additional information in the cache key. To remove stale rows in the target index, the lineage tracking works well again. Note that some other systems handle stale output deletions on source update/deletion by replaying the transformation logic on the previous version of input: this only works well when transformation is fully deterministic and never upgraded. CocoIndex's lineage tracking based approach doesn't have this limitation: it's robust to transformation logic non-determinism and changes. Example 4: Multiple inputs involved: Merge / Lookup / Clustering All examples above are simple cases: each single input row (e.g. a document) is involved independently during each specific transformation. CocoIndex is a highly customizable framework, not only limited to simple chunking and embedding. It allows users for more complex advanced transformations, such as: Merge. For example, you're bulding an index for "all AI products", and you want to combine information from multiple sources, some product exists in one source and some in multiple. For each product, you want to combine information from different sources.
Lookup. For example, you also have a data source about company information. During you transformation for each product, you want to enrich it with information of the company building the product, so a lookup for the company information is needed.
Clustering. For example, you want to cluster different products into scenarios, and create cluster-level summaries based on information of products in the cluster. Merge. For example, you're bulding an index for "all AI products", and you want to combine information from multiple sources, some product exists in one source and some in multiple. For each product, you want to combine information from different sources. Merge Lookup. For example, you also have a data source about company information. During you transformation for each product, you want to enrich it with information of the company building the product, so a lookup for the company information is needed. Lookup Clustering. For example, you want to cluster different products into scenarios, and create cluster-level summaries based on information of products in the cluster. Clustering The common theme is that during transformation, multiple input rows (coming from single or multiple sources) need to be involved at the same time. Once a single input row is updated or deleted, CocoIndex will need to fetch other related rows from the the same or other sources. Here which other rows are needed is based on which are involved in the transformations. CocoIndex keeps track of such relationships, and will fetch related rows and trigger necessary reprocessings incrementally. Change Data Capture (CDC) 1. When source supports push change Some source connectors support push change. For example, Google Drive supports drive-level changelog and send change notifications to your public URL, which is applicable for team drive and personal drive (only by OAuth, service account not supported). When a file is created, updated, or deleted, CocoIndex could compute based on the diff. 2. Metadata-based, last modified only Some source connectors don't support push change, but provide metadata and file system operations that list most recent changed files. For example, Google Drive with service account. CocoIndex could monitor the change based on last modified vs last poll time, periodic trigger to check modified. However this cannot capture full change, for example a file has been deleted. 3. Metadata-based, Fullscan Some source connectors have limited capabilities with listing files, but provide metadata that list all files. For example, with local files, we'd need to traverse all files in all directories and subdirectories recursively to get the full list. When the number of files is large, it's expensive to traverse all files. Cache In CocoIndex, every piece of the lego block in the pipeline can be cached. Custom functions can take a paramter cache. When True, the executor will cache the result of the function for reuse during reprocessing. We recommend to set this to True for any function that is computationally intensive. Output will be reused if all these unchanged: spec (if exists), input data, behavior of the function. For this purpose, a behavior_version needs to be provided, and should increase on behavior changes. For example, this enables cache for a standalone function, see full code example here: @cocoindex.op.executor_class(gpu=True, cache=True, behavior_version=1)
class PdfToMarkdownExecutor:
    """Executor for PdfToMarkdown."""
      ... @cocoindex.op.executor_class(gpu=True, cache=True, behavior_version=1)
class PdfToMarkdownExecutor:
    """Executor for PdfToMarkdown."""
      ...

Why Recompute Everything When You Can Use This Solution to Keep Your AI Index Fresh Automatically

Like most people in tech, I love my gadgets. Over the years, I’ve had  a Whoop, an Oura Ring, an Apple watch and a Garmin. But while I was drowning in data, I was starving for meaning. Like most people in tech, I love my gadgets. Over the years, I’ve had  a Whoop, an Oura Ring, an Apple watch and a Garmin. But while I was drowning in data, I was starving for meaning. I was tracking everything: steps, HRV, sleep, readiness scores, resting heart rate, calories, workouts. You name it. But despite all this data, I wasn’t seeing results. I wasn’t getting leaner. I wasn’t feeling more energized. I wasn’t making better choices. Instead, I was caught in what I now call the quantified self trap: drowning in data, but starving for meaning. quantified self trap Wearables Are Data-Rich, Insight-Poor Every app had its own dashboard, scores, colors, and buzzwords. I had streaks to maintain, rings to close, recovery zones to monitor, but nothing was translating into real behavior change. Most days I’d open three different apps and still not know what to do next. real What’s worse: I felt guilty. Like I was the problem. But I wasn’t the problem. The tools were. All this data was reactive. It told me what already happened. None of it helped me anticipate or design a better tomorrow. The Breakthrough: From Lagging Indicators to Leading Behaviors Eventually, I realized I was measuring the wrong things. Weight is a lagging indicator. HRV, too. Even readiness scores. What I needed were actionable, trackable, daily leading indicators—behaviors I could control. lagging leading indicators So I created a framework: North Star Goal: e.g., Improve my HRV, Lose 20 pounds, sleep better, have more energy
Lagging Indicators: weight, HRV, body fat percentage
Leading Behaviors: workouts, walking, sleep time, hydration, macros, etc.
Contextual Activities: travel, alcohol, screen time, sauna, meditation North Star Goal: e.g., Improve my HRV, Lose 20 pounds, sleep better, have more energy North Star Goal: Lagging Indicators: weight, HRV, body fat percentage Lagging Indicators: Leading Behaviors: workouts, walking, sleep time, hydration, macros, etc. Leading Behaviors: Contextual Activities: travel, alcohol, screen time, sauna, meditation Contextual Activities: I wanted to see how my inputs (behaviors) were actually impacting my outputs (results). Building Echo: The MVP I didn’t wait for funding or a cofounder. I used no-code tools to build Echo as an MVP for myself: Tally to create a simple daily journal where I log my behaviors.
Airtable to store my journal entries and wearable data.
Zapier to automate reminders and data updates.
Google Docs and Slides to generate monthly reports with charts showing correlations between behaviors and results. Tally to create a simple daily journal where I log my behaviors. Tally Airtable to store my journal entries and wearable data. Airtable Zapier to automate reminders and data updates. Zapier Google Docs and Slides to generate monthly reports with charts showing correlations between behaviors and results. Google Docs Slides Designing Experiments and Running Correlation Analysis What really brought Echo to life was treating my body like a sandbox for experimentation. I began running structured, self-directed experiments: What happens to my HRV if I take magnesium at night?
Does walking 8,000+ steps daily improve my fat loss more than just hitting workouts?
How does alcohol affect my sleep and my next-day energy? What happens to my HRV if I take magnesium at night? Does walking 8,000+ steps daily improve my fat loss more than just hitting workouts? How does alcohol affect my sleep and my next-day energy? and Using multivariable correlation analysis within Airtable and Google Sheets, I was able to examine patterns across weeks. Not just one-to-one relationships, but compounded ones—e.g., how sleep and protein intake influenced fat loss. Or how travel and poor hydration and late-night eating created weight spikes. and and and These weren’t random guesses anymore. They were real, personal insights backed by data. What I Learned (and am learning) Within two months of using Echo, I had insights I’d never gotten from any app: I always gained weight the week after a trip, even if I ate "okay"
Alcohol impacted my HRV more than sleep
My weight loss stalled every time I skipped morning walks, even with workouts
Travel + bad sleep + no walks = guaranteed fat gain I always gained weight the week after a trip, even if I ate "okay" Alcohol impacted my HRV more than sleep My weight loss stalled every time I skipped morning walks, even with workouts Travel + bad sleep + no walks = guaranteed fat gain Most importantly, I started making better choices—not because I was being forced to, but because I understood myself. understood I had designed a feedback loop that worked for me. me The Unexpected Ripple Effects When friends saw my monthly report, they asked me how I made it. Some started tracking the same way. A few asked if they could pay me to set it up for them. That’s when I realized: maybe Echo isn’t just for me. What’s Next for Echo I’m now working on turning Echo into a more complete product. A real app with: Direct integrations into wearables (Garmin, Apple, Fitbit, Whoop)


A smart journal that asks you the right questions based on your goals


A coaching layer that suggests weekly focus areas


A monthly report that turns data into insight—and insight into action Direct integrations into wearables (Garmin, Apple, Fitbit, Whoop) Direct integrations into wearables (Garmin, Apple, Fitbit, Whoop) A smart journal that asks you the right questions based on your goals A smart journal that asks you the right questions based on your goals A coaching layer that suggests weekly focus areas A coaching layer that suggests weekly focus areas A monthly report that turns data into insight—and insight into action A monthly report that turns data into insight—and insight into action No social feeds. No gamification. No vanity scores. Just real behavior change. Why I’m Building This Because I think a lot of people are like me. They’re not lazy. They’re not unmotivated. They’re just overwhelmed. They want to change. They want to feel better. But the data isn’t helping them decide what to do. decide Echo is my attempt to fix that. Not with gimmicks. But with clarity, simplicity, and reflection. Because the truth is: your body is already talking to you. You just need a system that knows how to listen. Want to try Echo? Want to try Echo? I'm looking for early testers who want to join the next round of experimentation. If you're using a wearable, have a goal you're trying to reach, and want to actually learn from your data, let’s connect. learn Sign up on my tally form https://tally.so/r/mZeNZV or visit www.logwithecho.com and I’ll set you up with a personalized journal and monthly insight report. https://tally.so/r/mZeNZV www.logwithecho.com Let’s turn your data into direction.

I Built an App to Hack My Health Using Data from My Garmin, and It Changed Everything

Introduction Picture this: you start a new project and, out of sheer habit, decide to slap a UUID as the ID on every single table. “What could possibly go wrong?”—after all, UUIDs are universal, globally unique, and basically the coolest thing out there, right? Sound familiar? In reality, this widespread fascination with UUIDs can drag down performance, bloat your indexes, and give you unnecessary headaches when maintaining your database. Let’s take a closer look at why UUIDs aren’t always the perfect fix and when they actually make sense. When UUIDs Actually Make Sense Distributed Systems A prime case for using UUIDs is when you’ve got dozens (or even hundreds) of independent nodes, each creating records without a shared counter. In that scenario, generating unique IDs locally is a lifesaver—it avoids collisions and doesn’t rely on a central coordinator. Generating the ID Up Front Sometimes, you need an object’s identifier before it even hits the database. Think of a mobile app that pre-creates an order and instantly needs an order number. With auto-increment from the DB, you have to insert first, then wait for a response; with a UUID, you’re good to go right away. Making It Hard to Guess Another big plus for UUIDs: they’re not easy to brute-force. If you’re building a public API or dealing with magic links (like password reset URLs), being unpredictable is crucial. While there are alternative ways to protect your endpoints (tokens, hashes, etc.), UUIDs are often chosen for convenience. Hiding the Insertion Order If you don’t want people to know how many rows are in your database or how fast they’re being added, auto-increment keys might spill the beans. A random-looking UUID is way less obvious and won’t let anyone figure out when or how many records you’ve inserted. Common Pitfalls and Gotchas With UUID Index Size and Overhead The first and most overlooked point: a UUID is 16 bytes, whereas BIGINT is only 8. No biggie for small datasets, but multiply that difference by hundreds of millions of rows, and your indexes could practically double in size. Bigger indexes mean more I/O, which can eat into performance. Fragmentation and Insertion Order Next, when you use sequential IDs, new entries typically end up at the “end” of the index—minimal fragmentation. But a UUID v4 is random, scattering new keys all over the place and forcing frequent page splits. This causes index bloat, more overhead, and extra maintenance (like VACUUM in PostgreSQL), leading your database to bulk up and slow down. Insert Performance Which ties into our third point: inserting in ascending order is easier, while random inserts require more fuss. The system has to figure out where to put each new record in the index, and if the index is already beefy, that’s even more overhead. Read Performance (Exact Lookups) Both BIGINT and UUIDs theoretically have O(log n) search time in a b-tree, but if your UUID-based index is bloated, you’ll be reading more pages off disk. On small-scale projects, that may not matter, but once you hit massive volumes—billions of rows—those extra reads can stack up and cause noticeable slowdowns. Index Size vs. Cache When an index swells beyond what fits in shared_buffers or the OS page cache, the database has to do more disk I/O. In a high-load setting, that’s a recipe for bottlenecks and lag. The “Magical Sharding” Misconception Some folks assume that random UUIDs magically deliver perfectly distributed sharding. In reality, proper sharding calls for a deliberate approach—hash-based, range-based, consistent hashing, etc. Simply generating random IDs won’t guarantee load balancing for free. Uniqueness and ID Generation Sure, a UUID is fantastic if you need to generate globally unique IDs without coordination—like if multiple nodes are all inserting data on their own. But if you’ve got a single service hitting a single database, “global uniqueness” might be overkill, adding more complexity than actual value. How to Handle It (and Keep Your DB Happy) If Possible, Go for Auto-Increment (IDENTITY, BIGSERIAL) In many situations, a straightforward auto-increment setup is a slam dunk: you get faster performance and smaller indexes. Plus, if your users’ data is protected by authentication and a well-thought-out ACL or RBAC model, there’s really no worry—nobody can peek at someone else’s records by guessing IDs. The Hybrid Approach Nothing stops you from using sequential IDs internally and then translating them into some kind of randomized string (token, UUID, hash, etc.) when exposing them via an external API. That way, everything is efficient inside your system, and outsiders remain blissfully unaware of your real IDs under the hood. Don’t Expect Automatic Sharding Magic If you’re dealing with sharding, you’ll still need a solid plan. UUIDs alone aren’t a silver bullet for distributing data—hash functions, consistent hashing, or ranges have to be properly tuned. “Random = perfect distribution” is wishful thinking, not a real strategy. Conclusion Here’s the bottom line: UUIDs are a lifesaver when you’re dealing with a truly distributed system or when you need to know your IDs upfront or make them unguessable. But if you’ve only got one service writing to one database and don’t actually need that global uniqueness, you’ll likely suffer more from oversized indexes and random insertion patterns than you’ll benefit. Remember, the choice of which type to use should be deliberate. If you need randomness or that global uniqueness, go ahead and use a UUID. Otherwise, stick with classic sequential IDs. Making a mindful decision about your ID strategy keeps your database lean and your development process running smoothly—no extra baggage required. Introduction Picture this: you start a new project and, out of sheer habit, decide to slap a UUID as the ID on every single table. “ What could possibly go wrong?” —after all, UUIDs are universal, globally unique, and basically the coolest thing out there, right? Sound familiar? What could possibly go wrong?” In reality, this widespread fascination with UUIDs can drag down performance, bloat your indexes, and give you unnecessary headaches when maintaining your database. Let’s take a closer look at why UUIDs aren’t always the perfect fix and when they actually make sense. When UUIDs Actually Make Sense Distributed Systems A prime case for using UUIDs is when you’ve got dozens (or even hundreds) of independent nodes, each creating records without a shared counter. In that scenario, generating unique IDs locally is a lifesaver—it avoids collisions and doesn’t rely on a central coordinator. Generating the ID Up Front Sometimes, you need an object’s identifier before it even hits the database. Think of a mobile app that pre-creates an order and instantly needs an order number. With auto-increment from the DB, you have to insert first, then wait for a response; with a UUID, you’re good to go right away. Making It Hard to Guess Another big plus for UUIDs: they’re not easy to brute-force. If you’re building a public API or dealing with magic links (like password reset URLs), being unpredictable is crucial. While there are alternative ways to protect your endpoints (tokens, hashes, etc.), UUIDs are often chosen for convenience. magic links Hiding the Insertion Order If you don’t want people to know how many rows are in your database or how fast they’re being added, auto-increment keys might spill the beans . A random-looking UUID is way less obvious and won’t let anyone figure out when or how many records you’ve inserted. spill the beans Common Pitfalls and Gotchas With UUID Index Size and Overhead The first and most overlooked point: a UUID is 16 bytes, whereas BIGINT is only 8. No biggie for small datasets, but multiply that difference by hundreds of millions of rows, and your indexes could practically double in size. Bigger indexes mean more I/O, which can eat into performance. Fragmentation and Insertion Order Next, when you use sequential IDs, new entries typically end up at the “end” of the index—minimal fragmentation. But a UUID v4 is random, scattering new keys all over the place and forcing frequent page splits. This causes index bloat, more overhead, and extra maintenance (like VACUUM in PostgreSQL), leading your database to bulk up and slow down. Insert Performance Which ties into our third point: inserting in ascending order is easier, while random inserts require more fuss. The system has to figure out where to put each new record in the index, and if the index is already beefy, that’s even more overhead. Read Performance (Exact Lookups) Both BIGINT and UUIDs theoretically have O(log n) search time in a b-tree, but if your UUID-based index is bloated, you’ll be reading more pages off disk. On small-scale projects, that may not matter, but once you hit massive volumes—billions of rows—those extra reads can stack up and cause noticeable slowdowns. Index Size vs. Cache When an index swells beyond what fits in shared_buffers or the OS page cache, the database has to do more disk I/O. In a high-load setting, that’s a recipe for bottlenecks and lag. The “Magical Sharding” Misconception Some folks assume that random UUIDs magically deliver perfectly distributed sharding. In reality, proper sharding calls for a deliberate approach—hash-based, range-based, consistent hashing, etc. Simply generating random IDs won’t guarantee load balancing for free . for free Uniqueness and ID Generation Sure, a UUID is fantastic if you need to generate globally unique IDs without coordination—like if multiple nodes are all inserting data on their own. But if you’ve got a single service hitting a single database, “global uniqueness” might be overkill, adding more complexity than actual value. How to Handle It (and Keep Your DB Happy) If Possible, Go for Auto-Increment (IDENTITY, BIGSERIAL) In many situations, a straightforward auto-increment setup is a slam dunk: you get faster performance and smaller indexes. Plus, if your users’ data is protected by authentication and a well-thought-out ACL or RBAC model, there’s really no worry—nobody can peek at someone else’s records by guessing IDs. The Hybrid Approach Nothing stops you from using sequential IDs internally and then translating them into some kind of randomized string (token, UUID, hash, etc.) when exposing them via an external API. That way, everything is efficient inside your system, and outsiders remain blissfully unaware of your real IDs under the hood. Don’t Expect Automatic Sharding Magic Automatic If you’re dealing with sharding, you’ll still need a solid plan. UUIDs alone aren’t a silver bullet for distributing data—hash functions, consistent hashing, or ranges have to be properly tuned. “Random = perfect distribution” is wishful thinking, not a real strategy. Conclusion Here’s the bottom line: UUIDs are a lifesaver when you’re dealing with a truly distributed system or when you need to know your IDs upfront or make them unguessable. But if you’ve only got one service writing to one database and don’t actually need that global uniqueness, you’ll likely suffer more from oversized indexes and random insertion patterns than you’ll benefit. Remember, the choice of which type to use should be deliberate. If you need randomness or that global uniqueness, go ahead and use a UUID. Otherwise, stick with classic sequential IDs. Making a mindful decision about your ID strategy keeps your database lean and your development process running smoothly—no extra baggage required. mindful decision

Stories, News & Mentions about EVERY

Every’s Stories on HackerNoon

Every's News & Mentions