Brightline, the first new US private passenger railroad in more than a century, is betting it can lure more Floridians out of their cars — but first, it is refinancing roughly $4 billion in debt.

Fortress-Backed Brightline Asks Investors to Bet on Florida Rail

Much has changed in Mecklenburg County since the Red Line, a commuter rail between Uptown and Lake Norman, was first envisioned at least a quarter century ago · Why it matters: Even though the train would run on existing tracks, Charlotte Area Transit System must consider all the new development ...

Red Line: Everything to know about north Mecklenburg County's future train - Axios Charlotte

Despite federal backing of bullet train infrastructure in the U.S., a truly high-speed future is unlikely while it remains a partisan issue.

High-Speed Rail Between U.S. Hubs May Be Closer Than It Appears – Commercial Observer

HART CEO Lori Kahikina&#x27;s annual evaluation was quite critical, citing a lack of progress in filling key positions and &quot;limited transparency&quot; with the rail board of directors.

Rail Chief's Lastest Evaluation Raises Questions About Whether She Has A Future With Rail - Honolulu Civil Beat

Questions mostly went unanswered at a public meeting last week. Rider-facing concerns like ticket prices, schedules, and start time are undetermined.

South Coast Rail service appears to be delayed, with a summer start 'unlikely'

BEVERLY, MASS. (WHDH) - Authorities are investigating a crash between a car and a Commuter Rail train in Beverly on Wednesday that sent an elderlyRead More

MBTA: Elderly driver ignored barriers before crash with commuter rail train in Beverly - Boston News, Weather, Sports | WHDH 7News

Almost nothing stops Japan’s famous high-speed bullet trains from running exactly on time – but a tiny snake slithering through a passenger carriage will do the trick, albeit for just 17 minutes.

Snake on a bullet train causes rare railway delay in Japan | CNN

Xcel Energy lines in the North Loop, which provide power to parts of downtown Minneapolis, will need to be moved to make way for the Blue Line light rail extension.

Metro Transit's light rail project encounters new obstacle in Minneapolis’ North Loop: Major utility lines

Deutsche Bahn’s vision includes hi-tech cabins and more efficient engineering work amid growing dissatisfaction with the railway

Efficient, reliable – and fragrant: German rail firm announces plans for the future | Germany | The Guardian

A disabled Amtrak train halted NJ Transit service on the Northeast Corridor due to overhead wire issues.

New Jersey Transit Northeast Corridor service disrupted by overhead wire issue - ABC7 New York

Raiil

raiil

A Revolution Quietly Led by the Company Trusted by Governments and Fortune 500 Giants In an era where technological noise often drowns true innovation, droppGroup emerges as a quiet giant. Behind closed boardrooms and sovereign discussions, they are building something profound: the rails of the New Internet and the foundation of the AI-driven economy. Governments trust them. Fortune 500 companies rely on them. And soon, the world will realize that droppGroup is not just participating in the next digital age - they are defining it. Today's internet was built for information. The new internet, the one droppGroup is forging, is being built for intelligence, value exchange and autonomy. droppGroup is pioneering enterprise-grade blockchain solutions, AI-driven infrastructures and sovereign asset tokenization, moving beyond speculation into real-world utility. They enable sovereign assets, corporate infrastructure and human capital itself to be digitized, tokenized and activated. At the core is droppOne, their flagship platform carefully built over 7 years, an agentic AI system blending blockchain, smart contracts and multimodal AI models to create fully autonomous digital ecosystems. From sovereign housing markets to AI-driven workforce optimization at national oil giants like Saudi Aramco, droppOne proves that droppGroup doesn't theorize the future, they operationalize it. When governments seek to modernize trillion-dollar infrastructures, they turn to droppGroup. When Fortune 500 giants need to integrate AI with real-world financial systems, they call droppGroup. This level of trust is not granted lightly. Saudi Arabia's Vision 2030? droppGroup is embedded within it. Global tech titans like Cisco, Nvidia and Oracle? They are partners, not just clients. droppGroup has cracked the code on bridging the public and private sectors into one interoperable, AI-driven financial and operational web - a feat few companies in history have achieved. Through their pioneering work in Real-World Asset (RWA) tokenization via their JV droppRWA, droppGroup is transforming traditionally illiquid assets, energy infrastructure, real estate, sovereign credit, into programmable financial instruments. This isn't "blockchain hype"; it's a pragmatic, compliant pathway for massive value unlocks across global markets. By providing sovereign-grade tokenization services, droppGroup isn't just moving assets onto blockchains, they are building the highways on which the next generation of finance, governance and commerce will travel. Where most AI today focuses on content generation or narrow tasks, droppGroup's agentic systems focus on building autonomous infrastructures. Their solutions enable AI agents that reason, act and transact, replacing entire operational layers of companies, municipalities and sovereign programs with self-improving, self-operating systems. As industries wake up to the profound shift underway, they will find droppGroup already years ahead, having quietly built the infrastructure that will power the AI economy for generations to come. droppGroup is not following the future. droppGroup is building it. And when history looks back at who laid the rails of the new internet, the decentralized, intelligent, sovereign internet, it will find the name droppGroup written deep into its foundations**.** A Revolution Quietly Led by the Company Trusted by Governments and Fortune 500 Giants A Revolution Quietly Led by the Company Trusted by Governments and Fortune 500 Giants A Revolution Quietly Led by the Company Trusted by Governments and Fortune 500 Giants In an era where technological noise often drowns true innovation, droppGroup emerges as a quiet giant. Behind closed boardrooms and sovereign discussions, they are building something profound: the rails of the New Internet and the foundation of the AI-driven economy. Governments trust them. Fortune 500 companies rely on them. And soon, the world will realize that droppGroup is not just participating in the next digital age - they are defining it. droppGroup Today's internet was built for information. The new internet, the one droppGroup is forging, is being built for intelligence, value exchange and autonomy. droppGroup is pioneering enterprise-grade blockchain solutions, AI-driven infrastructures and sovereign asset tokenization, moving beyond speculation into real-world utility. They enable sovereign assets, corporate infrastructure and human capital itself to be digitized, tokenized and activated. At the core is droppOne, their flagship platform carefully built over 7 years, an agentic AI system blending blockchain, smart contracts and multimodal AI models to create fully autonomous digital ecosystems. From sovereign housing markets to AI-driven workforce optimization at national oil giants like Saudi Aramco, droppOne proves that droppGroup doesn't theorize the future, they operationalize it. When governments seek to modernize trillion-dollar infrastructures, they turn to droppGroup. When Fortune 500 giants need to integrate AI with real-world financial systems, they call droppGroup. This level of trust is not granted lightly. Saudi Arabia's Vision 2030? droppGroup is embedded within it. Global tech titans like Cisco, Nvidia and Oracle? They are partners, not just clients. droppGroup has cracked the code on bridging the public and private sectors into one interoperable, AI-driven financial and operational web - a feat few companies in history have achieved. Through their pioneering work in Real-World Asset (RWA) tokenization via their JV droppRWA, droppGroup is transforming traditionally illiquid assets, energy infrastructure, real estate, sovereign credit, into programmable financial instruments. This isn't "blockchain hype"; it's a pragmatic, compliant pathway for massive value unlocks across global markets. By providing sovereign-grade tokenization services, droppGroup isn't just moving assets onto blockchains, they are building the highways on which the next generation of finance, governance and commerce will travel. Where most AI today focuses on content generation or narrow tasks, droppGroup's agentic systems focus on building autonomous infrastructures. Their solutions enable AI agents that reason, act and transact, replacing entire operational layers of companies, municipalities and sovereign programs with self-improving, self-operating systems. As industries wake up to the profound shift underway, they will find droppGroup already years ahead, having quietly built the infrastructure that will power the AI economy for generations to come. droppGroup is not following the future. droppGroup is building it. building And when history looks back at who laid the rails of the new internet, the decentralized, intelligent, sovereign internet, it will find the name droppGroup written deep into its foundations**.**

droppGroup Is Laying the Rails for the New Internet & AI-driven economy 

droppGroup lê die spoor vir die nuwe Internet & AI-gedrewe ekonomie

droppGroup поставя пистите за новата интернет и изкуствения интелект икономика

DroppGroup staví železnice pro nový internet a ekonomiku řízenou umělou inteligencí

droppGroup lanza las raíces para la nueva economía basada en Internet y la IA

droppGroup lance les rails pour la nouvelle économie Internet & AI

droppGroup מכינה את המסלול עבור האינטרנט החדש והכלכלה המונעת על ידי AI

droppGroup- ը նոր ինտերնետային եւ AI- ի վերահսկող արդյունաբերության համար

DroppGroup Lakukan Langkah-Langkah Untuk Ekonomi Internet & AI Baru

droppGroupは、新しいインターネットとAI駆動型経済のための鉄道を築いています。

droppGroup აშენებს ახალი ინტერნეტ და AI-driven ეკონომიკას

Ny droppGroup dia mametraka ny lalana ho an'ny aterineto vaovao sy ny toekarena mifototra amin'ny AI

droppGroup د نوي انټرنیټ او AI-driven اقتصاد لپاره د ریلونو جوړوي

AI agents for code generation have gained popularity and attention over the last few months. Large language models (LLMs) can churn out a lot of simple code, but they’re often not very good at managing complexity or making careful, coordinated changes across a large codebase. As we move toward improving the effectiveness of AI agents in coding, I think there’s a strong case to be made for bringing back something that was very popular in the Ruby community in the early 2010s: Test-Driven Development (TDD). Test-Driven Development (TDD) TDD, where tests are written before any actual implementation code, could offer the structure and discipline that AI agents need to make better decisions during development. When you define the tests first, you're essentially guiding the AI agent to think in terms of input/output and side effects before diving into the actual implementation. This makes sure that the AI focuses on modularity and testability, which can prevent the unstructured code generation that often leads to issues down the line. By breaking the problem into testable units, the agent can implement each layer of functionality in isolation, reducing the risk of errors and making debugging easier. A great book from the 2000s, "Working Effectively with Legacy Code," described legacy code as "any code without tests." I think this definition is going to become even more relevant with AI-generated code. Without tests, AI agents are more likely to produce tightly coupled, untestable code, which becomes harder for both humans and AI to maintain. "Working Effectively with Legacy Code," But if we enforce TDD principles, whether through context in the prompt or cursor rules that require the AI to follow a certain order (e.g., write tests first, then functions), we can move toward a future where AI-generated code is far more reliable and maintainable. The Law of Demeter and AI Agents Another programming principle that could make a huge difference in guiding AI agents is the Law of Demeter, which was widely emphasized in object-oriented design during the Ruby era. The Law of Demeter dictates that objects should only communicate with their immediate neighbors rather than drilling through layers of objects to access data. Law of Demeter For example, instead of writing code like user.settings.priceSettings.timeZone, you should aim for user.timeZone or settings.timeZone, which keeps the interaction between objects simple and localized. user.settings.priceSettings.timeZone user.timeZone settings.timeZone Following this principle will have a few impacts on AI agents. When a single function invocation involves a long chain of objects, this will require the context to include additional files for each object. Additionally, any changes to an object’s structure then spreads out and requires changes everywhere it was used, which will be many files if the code often “reaches through” one object to another to directly invoke functions or access attributes. When code respects the Law of Demeter, it's more modular and loosely coupled, which means fewer places for things to break. If an AI agent generates code that respects these boundaries, the code will be far easier to maintain, debug, and extend. This is especially important because AI agents are not yet adept at debugging complex issues, and the simpler the relationships between objects, the easier it is to isolate problems. Bringing Back Ruby's Influence In the early 2010s, a book called Practical Object-Oriented Design in Ruby (POODR) had a significant influence on how developers thought about writing clean, modular code. The book laid out principles like DRY (Don't Repeat Yourself) and emphasized keeping functions small, readable, and focused. These principles are not only great for human developers but could also significantly benefit AI agents. Small, well-defined functions allow the AI to understand the code at the necessary layer of abstraction to make meaningful changes. Practical Object-Oriented Design in Ruby (POODR) DRY (Don't Repeat Yourself) Rubyists were also big on using domain-specific languages (DSLs), where code reads almost like plain English, and this level of readability is exactly what AI needs to "understand" the intent behind the code. With clear, descriptive methods and classes, there’s less ambiguity, and the AI can make smarter decisions about how to extend or refactor code. domain-specific languages (DSLs) A Ruby Example class User
  attr_reader :settings

  def initialize(settings)
    @settings = settings
  end

  def time_zone
    settings.time_zone
  end
end

class Settings
  attr_reader :time_zone

  def initialize(time_zone)
    @time_zone = time_zone
  end
end

settings = Settings.new('UTC')
user = User.new(settings)

puts user.time_zone  # Output: 'UTC' class User
  attr_reader :settings

  def initialize(settings)
    @settings = settings
  end

  def time_zone
    settings.time_zone
  end
end

class Settings
  attr_reader :time_zone

  def initialize(time_zone)
    @time_zone = time_zone
  end
end

settings = Settings.new('UTC')
user = User.new(settings)

puts user.time_zone  # Output: 'UTC' In this example, the Law of Demeter is respected because consumers of the User class don’t need to know about the entire chain of objects (user.settings.timeZone), but rather accesses the time_zone property directly on the user.timeZone. This may seem insignificant, but it means any code that uses the user.timeZone will not be affected if the settings object or however the user chooses to implement its timeZone changes. User user.settings.timeZone time_zone user.timeZone user.timeZone It also means any code prompts touching the user.timeZone won’t need any sense of what is going on in the setting object which means more room in the context for meaningful information. When this convention is followed across an entire code base, the consequences are very noticeable in terms of modularity and ease of editing code. user.timeZone Looking Forward As AI agents continue to develop, I expect we’ll start seeing a resurgence of these programming styles that enforce modularity and testability. TDD and principles like the Law of Demeter can help AI agents navigate the complexity of large codebases by guiding them to make better design decisions. With TDD, AI can work in steps, focusing on writing tests first to ensure that each piece of code is isolated and functional before moving on to the next. When paired with readable, modular code, these agents might finally start making more significant code changes that are both reliable and maintainable.

Test Driven Development and Rails Era Best Practices Could Improve AI Generated Code

Authors:
(1) Mengshuo Jia, Department of Information Technology and Electrical Engineering, ETH Zürich, Physikstrasse 3, 8092, Zürich, Switzerland;
(2) Gabriela Hug, Department of Information Technology and Electrical Engineering, ETH Zürich, Physikstrasse 3, 8092, Zürich, Switzerland;
(3) Ning Zhang, Department of Electrical Engineering, Tsinghua University, Shuangqing Rd 30, 100084, Beijing, China;
(4) Zhaojian Wang, Department of Automation, Shanghai Jiao Tong University, Dongchuan Rd 800, 200240, Shanghai, China;
(5) Yi Wang, Department of Electrical and Electronic Engineering, The University of Hong Kong, Pok Fu Lam, Hong Kong, China;
(6) Chongqing Kang, Department of Electrical Engineering, Tsinghua University, Shuangqing Rd 30, 100084, Beijing, China. Table of Links Abstract and 1. Introduction 2. Evaluated Methods 3. Review of Existing Experiments 4. Generalizability and Applicability Evaluations and 4.1. Predictor and Response Generalizability 4.2. Applicability to Cases with Multicollinearity and 4.3. Zero Predictor Applicability 4.4. Constant Predictor Applicability and 4.5. Normalization Applicability 5. Numerical Evaluations and 5.1. Experiment Settings 5.2. Evaluation Overview 5.3. Failure Evaluation 5.4. Accuracy Evaluation 5.5. Efficiency Evaluation 6. Open Questions 7. Conclusion Appendix A and References 4. Generalizability and Applicability Evaluations 4.1. Predictor and Response Generalizability While PPFL methods are often constrained in their choice of predictors and responses due to specific physical formulations, DPFL methods generally offer a more flexible framework. This flexibility indicates the potential for DPFL approaches to accommodate arbitrary known variables (including 𝑃 and 𝑄 of the PQ buses, 𝑉 of the slack and PV buses, and 𝜃 of the slack bus) as predictors, and arbitrary unknown variables (including 𝑃 of the slack bus, 𝑄 of the slack and PV buses, 𝑉 of the PQ buses, 𝜃 of the PQ and PV buses, and all active/reactive line flows, i.e., PF, PT, QF, QT) as responses. However, due to various factors, not all DPFL methods can achieve this level of generalizability: • For the PLS_BDL and PLS_BDLY2 methods, using 𝑉 , 𝑃 , and 𝑄 as predictors is enforced by the bundle strategy [6] they adopt. This strategy, designed to address variations in bus types, inherently constrains the choice of predictors by pre-defining known and unknown variables. • The LCP_BOX and LCP_JGD methods integrate physical knowledge of power flows by formulating constraints based on the Jacobian matrix derived from AC power flow equations expressed in polar coordinates [6]. Within this Jacobian matrix, 𝑃 and 𝑄 are treated as known variables, while 𝑉 and 𝜃 are considered unknown variables. • The LCP_COU method is specifically designed to linearly estimate the values of branch flows by leveraging the terminal voltages and angles as predictive variables [6]. Consequently, the method can only employ 𝑉 and 𝜃 as predictors, and treat PF, PT, QF, and QT as responses. • For the DC_LS and DLPF_C methods, since they incorporate the DC and DLPF models respectively into their framework [6], they must align their selection of predictors and responses with the underlying physical models they adopt. Note that the constrained flexibility in choosing predictors and responses results in notable limitations. First, these methods might not leverage all available known data for model training, leading to potential information loss. For instance, the DC_LS method only uses measurements of 𝑃 , disregarding a large amount of known voltage data. Second, the capability to predict unknown variables using the developed linear model may be restricted. For example, the LCP_BOX method is restricted to calculating branch flow values, leading to a quite limited functional scope. 4.2. Applicability to Cases with Multicollinearity The ordinary least squares method struggles with multicollinearity [6]. Methods LS, LS_CLS, and LS_REC share this limitation, since they are all based on the ordinary least squares framework. Additionally, LS_SVD and LS_TOL are also affected by this problem, as discussed in [6]. Subsequent experiments will numerically demonstrate their limitations in this context. 4.3. Zero Predictor Applicability The issue of zero predictors arises when certain known variable measurements in the training dataset are consistently zero. A typical example is the inclusion of the slack bus angle in the predictor set, whose value is commonly set as zero and remains zero throughout. Other instances may involve PQ buses where active/reactive power consumption is zero during the measurement period. This situation leads to zero columns in the predictor dataset matrix (where columns represent different variables, and rows represent individual measurements). Not all DPFL methods can handle these zero columns effectively: • Methods based on ordinary least squares, including LS, LS_CLS, and LS_REC, have difficulties with zero predictors, as these zero columns render the Gram matrix of the predictor matrix non-invertible, thereby leading to the failure of these methods. 4.4. Constant Predictor Applicability The constant predictor issue extends beyond the zero predictor problem, occurring when measurements of certain variables in the training dataset remain constant, not necessarily zero. A typical example is the fixed terminal voltages at PV buses, which normally stay constant over the measurement period, resulting in constant-value columns in the predictor matrix. 4.5. Normalization Applicability As detailed in [6], incorporating physical knowledge into DPFL methods can become problematic with datasets normalized via variance-scaling techniques, like unit-energy normalization, where each variable is normalized independently. This independent normalization disrupts the inherent physical relationships among variables, such as those represented in the Jacobian matrix or through coupling relationships, rendering methods like RR_VCS, LCP_BOX, LCP_COU, LCP_JGD, DC_LS, and DLPF_C inapplicable. This paper is available on arxiv under CC BY-NC-ND 4.0 Deed (Attribution-Noncommercial-Noderivs 4.0 International) license. Authors: (1) Mengshuo Jia, Department of Information Technology and Electrical Engineering, ETH Zürich, Physikstrasse 3, 8092, Zürich, Switzerland; (2) Gabriela Hug, Department of Information Technology and Electrical Engineering, ETH Zürich, Physikstrasse 3, 8092, Zürich, Switzerland; (3) Ning Zhang, Department of Electrical Engineering, Tsinghua University, Shuangqing Rd 30, 100084, Beijing, China; (4) Zhaojian Wang, Department of Automation, Shanghai Jiao Tong University, Dongchuan Rd 800, 200240, Shanghai, China; (5) Yi Wang, Department of Electrical and Electronic Engineering, The University of Hong Kong, Pok Fu Lam, Hong Kong, China; (6) Chongqing Kang, Department of Electrical Engineering, Tsinghua University, Shuangqing Rd 30, 100084, Beijing, China. Authors: Authors: (1) Mengshuo Jia, Department of Information Technology and Electrical Engineering, ETH Zürich, Physikstrasse 3, 8092, Zürich, Switzerland; (2) Gabriela Hug, Department of Information Technology and Electrical Engineering, ETH Zürich, Physikstrasse 3, 8092, Zürich, Switzerland; (3) Ning Zhang, Department of Electrical Engineering, Tsinghua University, Shuangqing Rd 30, 100084, Beijing, China; (4) Zhaojian Wang, Department of Automation, Shanghai Jiao Tong University, Dongchuan Rd 800, 200240, Shanghai, China; (5) Yi Wang, Department of Electrical and Electronic Engineering, The University of Hong Kong, Pok Fu Lam, Hong Kong, China; (6) Chongqing Kang, Department of Electrical Engineering, Tsinghua University, Shuangqing Rd 30, 100084, Beijing, China. Table of Links Abstract and 1. Introduction Abstract and 1. Introduction 2. Evaluated Methods 3. Review of Existing Experiments 3. Review of Existing Experiments 4. Generalizability and Applicability Evaluations and 4.1. Predictor and Response Generalizability 4. Generalizability and Applicability Evaluations and 4.1. Predictor and Response Generalizability 4.2. Applicability to Cases with Multicollinearity and 4.3. Zero Predictor Applicability 4.2. Applicability to Cases with Multicollinearity and 4.3. Zero Predictor Applicability 4.4. Constant Predictor Applicability and 4.5. Normalization Applicability 4.4. Constant Predictor Applicability and 4.5. Normalization Applicability 5. Numerical Evaluations and 5.1. Experiment Settings 5. Numerical Evaluations and 5.1. Experiment Settings 5.2. Evaluation Overview 5.2. Evaluation Overview 5.3. Failure Evaluation 5.3. Failure Evaluation 5.4. Accuracy Evaluation 5.4. Accuracy Evaluation 5.5. Efficiency Evaluation 5.5. Efficiency Evaluation 6. Open Questions 6. Open Questions 7. Conclusion 7. Conclusion Appendix A and References Appendix A and References 4. Generalizability and Applicability Evaluations 4.1. Predictor and Response Generalizability While PPFL methods are often constrained in their choice of predictors and responses due to specific physical formulations, DPFL methods generally offer a more flexible framework. This flexibility indicates the potential for DPFL approaches to accommodate arbitrary known variables (including 𝑃 and 𝑄 of the PQ buses, 𝑉 of the slack and PV buses, and 𝜃 of the slack bus) as predictors, and arbitrary unknown variables (including 𝑃 of the slack bus, 𝑄 of the slack and PV buses, 𝑉 of the PQ buses, 𝜃 of the PQ and PV buses, and all active/reactive line flows, i.e., PF, PT, QF, QT) as responses. However, due to various factors, not all DPFL methods can achieve this level of generalizability: • For the PLS_BDL and PLS_BDLY2 methods, using 𝑉 , 𝑃 , and 𝑄 as predictors is enforced by the bundle strategy [6] they adopt. This strategy, designed to address variations in bus types, inherently constrains the choice of predictors by pre-defining known and unknown variables. • The LCP_BOX and LCP_JGD methods integrate physical knowledge of power flows by formulating constraints based on the Jacobian matrix derived from AC power flow equations expressed in polar coordinates [6]. Within this Jacobian matrix, 𝑃 and 𝑄 are treated as known variables, while 𝑉 and 𝜃 are considered unknown variables. • The LCP_COU method is specifically designed to linearly estimate the values of branch flows by leveraging the terminal voltages and angles as predictive variables [6]. Consequently, the method can only employ 𝑉 and 𝜃 as predictors, and treat PF, PT, QF, and QT as responses. • For the DC_LS and DLPF_C methods, since they incorporate the DC and DLPF models respectively into their framework [6], they must align their selection of predictors and responses with the underlying physical models they adopt. Note that the constrained flexibility in choosing predictors and responses results in notable limitations. First, these methods might not leverage all available known data for model training, leading to potential information loss. For instance, the DC_LS method only uses measurements of 𝑃 , disregarding a large amount of known voltage data. Second, the capability to predict unknown variables using the developed linear model may be restricted. For example, the LCP_BOX method is restricted to calculating branch flow values, leading to a quite limited functional scope. 4.2. Applicability to Cases with Multicollinearity The ordinary least squares method struggles with multicollinearity [6]. Methods LS, LS_CLS, and LS_REC share this limitation, since they are all based on the ordinary least squares framework. Additionally, LS_SVD and LS_TOL are also affected by this problem, as discussed in [6]. Subsequent experiments will numerically demonstrate their limitations in this context. 4.3. Zero Predictor Applicability The issue of zero predictors arises when certain known variable measurements in the training dataset are consistently zero. A typical example is the inclusion of the slack bus angle in the predictor set, whose value is commonly set as zero and remains zero throughout. Other instances may involve PQ buses where active/reactive power consumption is zero during the measurement period. This situation leads to zero columns in the predictor dataset matrix (where columns represent different variables, and rows represent individual measurements). Not all DPFL methods can handle these zero columns effectively: • Methods based on ordinary least squares, including LS, LS_CLS, and LS_REC, have difficulties with zero predictors, as these zero columns render the Gram matrix of the predictor matrix non-invertible, thereby leading to the failure of these methods. 4.4. Constant Predictor Applicability The constant predictor issue extends beyond the zero predictor problem, occurring when measurements of certain variables in the training dataset remain constant, not necessarily zero. A typical example is the fixed terminal voltages at PV buses, which normally stay constant over the measurement period, resulting in constant-value columns in the predictor matrix. 4.5. Normalization Applicability As detailed in [6], incorporating physical knowledge into DPFL methods can become problematic with datasets normalized via variance-scaling techniques, like unit-energy normalization, where each variable is normalized independently. This independent normalization disrupts the inherent physical relationships among variables, such as those represented in the Jacobian matrix or through coupling relationships, rendering methods like RR_VCS, LCP_BOX, LCP_COU, LCP_JGD, DC_LS, and DLPF_C inapplicable. This paper is available on arxiv under CC BY-NC-ND 4.0 Deed (Attribution-Noncommercial-Noderivs 4.0 International) license. This paper is available on arxiv under CC BY-NC-ND 4.0 Deed (Attribution-Noncommercial-Noderivs 4.0 International) license. available on arxiv

When Power Flow Models Go Off the Rails

Leveraging Turbo 8: Best Additions to Implement in Rails 8 Projects

The Rails World 2024 conference ended last week, and a lot of new components of the Rails ecosystem were released during it including Kamal 2. I decided to make some preparations for the upcoming changes. In March 2024, the Basecamp team released Thruster, a small, Go-based proxy server for Rails. While the original idea of Thruster was to provide the ability to build production-ready Rails applications from a single container for the ONCE project, it will fit perfectly into the Kamal ecosystem. Isn’t It a Redundancy? Wait? Another proxy server? Why do we need it? Allow me to explain. It doesn’t matter whether we use Traefik with Kamal v1 or Kamal-proxy with Kamal v2; inside the container, we still run Puma (or any other Ruby application server) that serves requests to the application. Besides this, Puma is also responsible for serving application assets – images, stylesheets, JavaScript files, etc. – to the clients. Before Kamal came into the scene, we usually had Nginx in our infrastructure schema. Nginx is a classic web server that can serve static files efficiently. Unfortunately, it is not adapted to container-based setups as you need to manage its configuration via a config file. However, without Nginx, Puma is not the best choice to serve static files. This is where Thruster comes into play. It wraps the Puma instance and efficiently serves static files with X-Sendfile acceleration, while Puma is responsible for the dynamic content. Thruster also provides GZip compression which was available in Traefik via middleware but won’t exist in kamal-proxy. GZip compression plays a crucial role in optimizing web performance by significantly reducing the size of files transmitted between a server and a client. By compressing assets like HTML, CSS, and JavaScript, GZIP decreases bandwidth usage and accelerates the loading times of web pages, providing users with a faster, more seamless browsing experience. This not only enhances user satisfaction but also improves search engine rankings, as faster websites tend to rank higher in search results. Additionally, reducing the size of data transfers lightens the load on servers, allowing them to handle more requests efficiently and lowering hosting costs. A reasonable question would be “Why I cannot do a GZIP compression in Rails?” Technically, you can with Rack::Deflater. But since Thruster is already responsible for serving public assets, it can also efficiently handle compression. Besides compression, Thruster also provides basic HTTP caching of public assets and HTTP/2 support. With Thruster, your Rails application can be treated as a black box, which can serve any kind of request efficiently. How to Use Thruster is straightforward to use if you’re already using Puma. First, you need to add Thruster to your Gemfile: # Gemfile

gem 'thruster' Run bundle install, and you are ready to go. Since Thruster is written in Go, the platform-specific binary will be downloaded and installed with the gem. I always create binstubs to have all the necessary commands in one place: $ bundle binstubs thruster By default, Thruster will listen on port 80, while Puma will stay on port 3000. Knowing this, we should update our application Dockerfile accordingly. I assume here that your application is already dockerized. I replaced the port that is getting exposed from 3000 to 80 and added ./bin/thrust to the default command. # Dockerfile

# Entrypoint prepares the database.
ENTRYPOINT ["/rails/bin/docker-entrypoint"]

# Start server via Thruster by default, this can be overwritten at runtime
EXPOSE 80
CMD ["./bin/thrust", "./bin/rails", "server"] The last change is to update ./bin/docker-entrypoint script. I always try to keep it as close to the original Rails template as possible. Below is the final version of the script. #!/bin/bash -e

# If running the rails server then create or migrate existing database
if [ "${@: -2:1}" == "./bin/rails" ] && [ "${@: -1:1}" == "server" ]; then
  ./bin/rails db:prepare
fi

exec "${@}" That is all! Thanks to the Traefik container-based configuration, it will read the exposed port from the container and route the traffic accordingly after you deploy the changes. After deploy is finished, you can log in to the container and check if Thruster is running: rails@docker:~$ ps aux
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
rails          1  0.0  0.3 1232848 13124 ?       Ssl  09:26   0:06 /usr/local/bundle/ruby/3.3.0/gems/thruster-0.1.8-x86_64-linux/exe/x86_64-linux/thrust ./bin/rails server Summary Since there are no visible cons of using Thruster in your Rails application, I highly recommend using it. It can improve the performance of your application and reduce the load on the server. It is also a good idea to use it as a preparation for the upcoming Kamal 2 release. The Rails World 2024 conference ended last week, and a lot of new components of the Rails ecosystem were released during it including Kamal 2. I decided to make some preparations for the upcoming changes. In March 2024, the Basecamp team released Thruster , a small, Go-based proxy server for Rails. While the original idea of Thruster was to provide the ability to build production-ready Rails applications from a single container for the ONCE project, it will fit perfectly into the Kamal ecosystem. Thruster Isn’t It a Redundancy? Wait? Another proxy server? Why do we need it? Allow me to explain. It doesn’t matter whether we use Traefik with Kamal v1 or Kamal-proxy with Kamal v2; inside the container, we still run Puma (or any other Ruby application server) that serves requests to the application. Besides this, Puma is also responsible for serving application assets – images, stylesheets, JavaScript files, etc. – to the clients. Before Kamal came into the scene, we usually had Nginx in our infrastructure schema. Nginx is a classic web server that can serve static files efficiently. Unfortunately, it is not adapted to container-based setups as you need to manage its configuration via a config file. However, without Nginx, Puma is not the best choice to serve static files. This is where Thruster comes into play. It wraps the Puma instance and efficiently serves static files with X-Sendfile acceleration, while Puma is responsible for the dynamic content. Thruster also provides GZip compression which was available in Traefik via middleware but won’t exist in kamal-proxy. GZip compression plays a crucial role in optimizing web performance by significantly reducing the size of files transmitted between a server and a client. By compressing assets like HTML, CSS, and JavaScript, GZIP decreases bandwidth usage and accelerates the loading times of web pages, providing users with a faster, more seamless browsing experience. via middleware This not only enhances user satisfaction but also improves search engine rankings, as faster websites tend to rank higher in search results. Additionally, reducing the size of data transfers lightens the load on servers, allowing them to handle more requests efficiently and lowering hosting costs. A reasonable question would be “Why I cannot do a GZIP compression in Rails?” Technically, you can with Rack::Deflater . But since Thruster is already responsible for serving public assets, it can also efficiently handle compression. Rack::Deflater Besides compression, Thruster also provides basic HTTP caching of public assets and HTTP/2 support. With Thruster, your Rails application can be treated as a black box, which can serve any kind of request efficiently. With Thruster, your Rails application can be treated as a black box, which can serve any kind of request efficiently. How to Use Thruster is straightforward to use if you’re already using Puma. First, you need to add Thruster to your Gemfile: # Gemfile

gem 'thruster' # Gemfile

gem 'thruster' Run bundle install, and you are ready to go. Since Thruster is written in Go, the platform-specific binary will be downloaded and installed with the gem. bundle install, I always create binstubs to have all the necessary commands in one place: $ bundle binstubs thruster $ bundle binstubs thruster By default, Thruster will listen on port 80, while Puma will stay on port 3000. Knowing this, we should update our application Dockerfile accordingly. I assume here that your application is already dockerized. I replaced the port that is getting exposed from 3000 to 80 and added ./bin/thrust to the default command. Dockerfile ./bin/thrust # Dockerfile

# Entrypoint prepares the database.
ENTRYPOINT ["/rails/bin/docker-entrypoint"]

# Start server via Thruster by default, this can be overwritten at runtime
EXPOSE 80
CMD ["./bin/thrust", "./bin/rails", "server"] # Dockerfile

# Entrypoint prepares the database.
ENTRYPOINT ["/rails/bin/docker-entrypoint"]

# Start server via Thruster by default, this can be overwritten at runtime
EXPOSE 80
CMD ["./bin/thrust", "./bin/rails", "server"] The last change is to update ./bin/docker-entrypoint script. I always try to keep it as close to the original Rails template as possible. ./bin/docker-entrypoint original Rails template Below is the final version of the script. #!/bin/bash -e

# If running the rails server then create or migrate existing database
if [ "${@: -2:1}" == "./bin/rails" ] && [ "${@: -1:1}" == "server" ]; then
  ./bin/rails db:prepare
fi

exec "${@}" #!/bin/bash -e

# If running the rails server then create or migrate existing database
if [ "${@: -2:1}" == "./bin/rails" ] && [ "${@: -1:1}" == "server" ]; then
  ./bin/rails db:prepare
fi

exec "${@}" That is all! Thanks to the Traefik container-based configuration, it will read the exposed port from the container and route the traffic accordingly after you deploy the changes. After deploy is finished, you can log in to the container and check if Thruster is running: rails@docker:~$ ps aux
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
rails          1  0.0  0.3 1232848 13124 ?       Ssl  09:26   0:06 /usr/local/bundle/ruby/3.3.0/gems/thruster-0.1.8-x86_64-linux/exe/x86_64-linux/thrust ./bin/rails server rails@docker:~$ ps aux
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
rails          1  0.0  0.3 1232848 13124 ?       Ssl  09:26   0:06 /usr/local/bundle/ruby/3.3.0/gems/thruster-0.1.8-x86_64-linux/exe/x86_64-linux/thrust ./bin/rails server Summary Since there are no visible cons of using Thruster in your Rails application, I highly recommend using it. It can improve the performance of your application and reduce the load on the server. It is also a good idea to use it as a preparation for the upcoming Kamal 2 release.

Rails Thruster 101: A Quick Guide

Upgrading From Rails 7.1 to Rails 7.2: A Step-by-Step Guide for Enhancing Your Application

The Noonification: Buh-Bye Webpack and Node.js, Hello Rails and Import Maps (8/7/2024)

I enjoy spending time learning new technologies. However, often the biggest drawback of working with new technologies are the inevitable pain points that come with early adoption. I saw this quite a bit when I was getting up to speed with Web3 in “How to Transition from Full-Stack Developer to Web3 Pioneer in 2022.” As software engineers, we’re accustomed to accepting these early-adopter challenges when giving new tech a test drive. What works best for me is to keep a running list of notes and commands I’ve executed since seemingly illogical steps don’t remain in my memory. Aside from Web3, I also found this challenge in the JavaScript space, with the semi-standard requirements of using Node.js and Webpack. I wanted to identify a solution where I could just use JavaScript as is without toiling away with Node.js and Webpack. I recently read how the Rails 7 release addressed this very situation. So, that’s the use case I’ll be covering in this article. About Rails To be fully transparent, my experience with Ruby and Ruby on Rails is little to none. I remember watching someone issue some commands to create a fully functional service years ago, and I thought, “Wow, that looks awesome.” But I’ve never spent time playing around with this approach to building services and applications. I’m pretty sure I saw that demo in early 2006 because Rails first emerged in late 2005. Like I saw in the demonstration, the end result was a service that supported the model-view-controller (MVC) design pattern, a pattern that I was familiar with through my early use of the Spring, Struts, JSF, and Seam frameworks. Rails maintains a promise to keep things straightforward while adhering to DRY (don’t repeat yourself) practices. To help honor this promise, Ruby uses Gems for engineers to introduce shared dependencies into their projects. Version 7 Highlights In late 2021, the seventh major version of Rails introduced some exciting features: Asynchronous querying – getting away from running queries serially
Encrypted database layer – securing data between the service and persistence layers
Comparison validator – allows object validation before persistence
Import maps – no longer require Node.js and Webpack for JavaScript libraries That last feature is what drove me to write this article. How Do Import Maps Work? At a high level, the importmaps-rails Gem allows developers to import maps into their applications. The use of /bin/importmap allows engineers to update, pin, or unpin dependencies as needed. This is similar to how Maven and Gradle work in Java-based projects. This eliminates needing to deal with the complexities related to bundling packages and transpiling ES6 and Babel. Goodbye Webpack! Goodbye Node.js! Let’s Build Something Since I hadn’t even touched Ruby on Rails in almost two decades, the first thing I needed to do was follow this guide to install Ruby 3.3 on my MacBook Pro. Once installed, I just needed to install the Ruby plugin as part of my IntelliJ IDEA IDE. Then, I created a new Ruby on Rails project in IntelliJ called import-map and specified the use of Importmap for the JavaScript framework: With the project created, I first wanted to see how easy it would be to use a local JavaScript library. So, I created a new JavaScript file called /public/jvc_utilities.js with the following contents: export default function() {
    console.log('*****************');
    console.log('* jvc-utilities *');
    console.log('* version 0.0.1 *');
    console.log('*****************');
} The default function simply echoes some commands to the JavaScript console. Next, I created an HTML file (/public/jvc-utilities.html) with the following contents: <!DOCTYPE html>
<html>
    <head>
        <title>jvc-utilities</title>
    </head>

    <script type="importmap">
        { "imports": { "jvc_utilities": "./jvc_utilities.js"} }
    </script>
    <script type="module">
        import JvcUtilities from "jvc_utilities";

        JvcUtilities();
    </script>

    <h3>jvc-utilities.html</h3>

    <p>Open the console to see the output of the 
       <code>JvcUtilities()</code> function.
    </p>
</html> This example demonstrates how a local JavaScript file can be used with a public HTML file— without any additional work. Next, I created a new controller called Example: bin/rails generate controller Example index I wanted to use the Lodash library for this example, so I used the following command to add the library to my import-map project: bin/importmap pin lodash To add some JavaScript-based functionality to the controller, I updated javascript/controllers/example_controller.js to look like this: import { Controller } from "@hotwired/stimulus"
import _ from "lodash"

export default class extends Controller {
  connect() {
    const array = [1, 2, 3]
    const doubled = _.map(array, n => n * 2)
    console.log('array', array)  // Output: [1, 2, 3]
    console.log('doubled', doubled)  // Output: [2, 4, 6]
    this.element.textContent = `array=${array} doubled=${doubled.join(', ')}`
  }
} This logic establishes an array of three values, and then it doubles the values. I use the Lodash map() method to do this. Finally, I updated views/example/index.html.erb to contain the following: <h3>Example Controller</h3>

<div data-controller="example"></div> At this point, the following URIs are now available: /jvc-utilities.html
/example/index Let’s Deploy and Validate Rather than run the Rails service locally, I thought I would use Heroku instead. This way, I could make sure my service could be accessible for other consumers. Using my Heroku account, I followed the “Getting Started on Heroku with Ruby” guide. Based upon my project, my first step was to add a file named Procfile with the following contents: web: bundle exec puma -C config/puma.rb Next, I used the Heroku CLI to create a new application in Heroku: heroku login
heroku create With the create command, I had the following application up and running: Creating app... done, ⬢ lit-basin-84681
https://lit-basin-84681-3f5a7507b174.herokuapp.com/ | https://git.heroku.com/lit-basin-84681.git This step also created the Git remote that the Heroku ecosystem uses. Now, all I needed do was push my latest updates to Heroku and deploy the application: git push heroku main With that, my code was pushed to Heroku, which then compiled and deployed my application. In less than a minute, I saw the following, letting me know that my application was ready for use: remote: Verifying deploy... done.
To https://git.heroku.com/lit-basin-84681.git
   fe0b7ad..1a21bdd  main -> main Then, I navigated to the /example/index page using my Heroku URL (which is unique to my application, but I have since taken it down): https://lit-basin-84681-3f5a7507b174.herokuapp.com/example/index This is what I saw: And when I viewed the JavaScript console in my browser, the following logs appeared: Navigating to /jvc-utilities.html, I saw the following information: When I viewed the JavaScript console in my browser, I saw the the following logs: Success. I was able to use a self-contained JavaScript library and also the public Lodash JavaScript library in my Rails 7 application—all by using Import Maps and without needing to deal with Webpack or Node.js. Buh-bye, Webpack and Node.js! Conclusion My readers may recall my personal mission statement, which I feel can apply to any IT professional: “Focus your time on delivering features/functionality that extends the value of your intellectual property. Leverage frameworks, products, and services for everything else.” — J. Vester In this article, I dove head-first into Rails 7 and used Import Maps to show how easily you can use JavaScript libraries without the extra effort of needing to use Webpack and Node.js. I was quite impressed by the small amount of time that was required to accomplish my goals despite it being over two decades since I had last seen Rails in action. From a deployment perspective, the effort to deploy the Rails application onto the Heroku platform consisted of the creation of a Procfile and three CLI commands. In both cases, Rails and Heroku adhere to my mission statement by allowing me to remain laser-focused on delivering value to my customers and not get bogged down by challenges with Webpack, Node.js, or even DevOps tasks. While I am certain we will continue to face not-so-ideal pain points when exploring new technologies, I am also confident that in time, we will see similar accomplishments as I demonstrated in this article. As always, my source code can be found on GitLab here. Have a really great day! I enjoy spending time learning new technologies. However, often the biggest drawback of working with new technologies are the inevitable pain points that come with early adoption. I saw this quite a bit when I was getting up to speed with Web3 in “ How to Transition from Full-Stack Developer to Web3 Pioneer in 2022 .” How to Transition from Full-Stack Developer to Web3 Pioneer in 2022 As software engineers, we’re accustomed to accepting these early-adopter challenges when giving new tech a test drive. What works best for me is to keep a running list of notes and commands I’ve executed since seemingly illogical steps don’t remain in my memory. Aside from Web3, I also found this challenge in the JavaScript space, with the semi-standard requirements of using Node.js and Webpack. I wanted to identify a solution where I could just use JavaScript as is without toiling away with Node.js and Webpack. I recently read how the Rails 7 release addressed this very situation . So, that’s the use case I’ll be covering in this article. this very situation About Rails To be fully transparent, my experience with Ruby and Ruby on Rails is little to none. I remember watching someone issue some commands to create a fully functional service years ago, and I thought, “Wow, that looks awesome.” But I’ve never spent time playing around with this approach to building services and applications. I’m pretty sure I saw that demo in early 2006 because Rails first emerged in late 2005. Like I saw in the demonstration, the end result was a service that supported the model-view-controller (MVC) design pattern, a pattern that I was familiar with through my early use of the Spring, Struts, JSF, and Seam frameworks. Rails maintains a promise to keep things straightforward while adhering to DRY (don’t repeat yourself) practices. To help honor this promise, Ruby uses Gems for engineers to introduce shared dependencies into their projects. Version 7 Highlights In late 2021, the seventh major version of Rails introduced some exciting features: Asynchronous querying – getting away from running queries serially Encrypted database layer – securing data between the service and persistence layers Comparison validator – allows object validation before persistence Import maps – no longer require Node.js and Webpack for JavaScript libraries Asynchronous querying – getting away from running queries serially Encrypted database layer – securing data between the service and persistence layers Comparison validator – allows object validation before persistence Import maps – no longer require Node.js and Webpack for JavaScript libraries That last feature is what drove me to write this article. How Do Import Maps Work? At a high level, the importmaps-rails Gem allows developers to import maps into their applications. The use of /bin/importmap allows engineers to update, pin, or unpin dependencies as needed. This is similar to how Maven and Gradle work in Java-based projects. importmaps-rails /bin/importmap This eliminates needing to deal with the complexities related to bundling packages and transpiling ES6 and Babel. Goodbye Webpack! Goodbye Node.js! Let’s Build Something Since I hadn’t even touched Ruby on Rails in almost two decades, the first thing I needed to do was follow this guide to install Ruby 3.3 on my MacBook Pro. Once installed, I just needed to install the Ruby plugin as part of my IntelliJ IDEA IDE. this guide install the Ruby plugin Then, I created a new Ruby on Rails project in IntelliJ called import-map and specified the use of Importmap for the JavaScript framework: import-map Importmap With the project created, I first wanted to see how easy it would be to use a local JavaScript library. So, I created a new JavaScript file called /public/jvc_utilities.js with the following contents: /public/jvc_utilities.js export default function() {
    console.log('*****************');
    console.log('* jvc-utilities *');
    console.log('* version 0.0.1 *');
    console.log('*****************');
} export default function() {
    console.log('*****************');
    console.log('* jvc-utilities *');
    console.log('* version 0.0.1 *');
    console.log('*****************');
} The default function simply echoes some commands to the JavaScript console. Next, I created an HTML file ( /public/jvc-utilities.html ) with the following contents: /public/jvc-utilities.html <!DOCTYPE html>
<html>
    <head>
        <title>jvc-utilities</title>
    </head>

    <script type="importmap">
        { "imports": { "jvc_utilities": "./jvc_utilities.js"} }
    </script>
    <script type="module">
        import JvcUtilities from "jvc_utilities";

        JvcUtilities();
    </script>

    <h3>jvc-utilities.html</h3>

    <p>Open the console to see the output of the 
       <code>JvcUtilities()</code> function.
    </p>
</html> <!DOCTYPE html>
<html>
    <head>
        <title>jvc-utilities</title>
    </head>

    <script type="importmap">
        { "imports": { "jvc_utilities": "./jvc_utilities.js"} }
    </script>
    <script type="module">
        import JvcUtilities from "jvc_utilities";

        JvcUtilities();
    </script>

    <h3>jvc-utilities.html</h3>

    <p>Open the console to see the output of the 
       <code>JvcUtilities()</code> function.
    </p>
</html> This example demonstrates how a local JavaScript file can be used with a public HTML file— without any additional work. Next, I created a new controller called Example : Example bin/rails generate controller Example index bin/rails generate controller Example index I wanted to use the Lodash library for this example, so I used the following command to add the library to my import-map project: Lodash library import-map bin/importmap pin lodash bin/importmap pin lodash To add some JavaScript-based functionality to the controller, I updated javascript/controllers/example_controller.js to look like this: javascript/controllers/example_controller.js import { Controller } from "@hotwired/stimulus"
import _ from "lodash"

export default class extends Controller {
  connect() {
    const array = [1, 2, 3]
    const doubled = _.map(array, n => n * 2)
    console.log('array', array)  // Output: [1, 2, 3]
    console.log('doubled', doubled)  // Output: [2, 4, 6]
    this.element.textContent = `array=${array} doubled=${doubled.join(', ')}`
  }
} import { Controller } from "@hotwired/stimulus"
import _ from "lodash"

export default class extends Controller {
  connect() {
    const array = [1, 2, 3]
    const doubled = _.map(array, n => n * 2)
    console.log('array', array)  // Output: [1, 2, 3]
    console.log('doubled', doubled)  // Output: [2, 4, 6]
    this.element.textContent = `array=${array} doubled=${doubled.join(', ')}`
  }
} This logic establishes an array of three values, and then it doubles the values. I use the Lodash map() method to do this. map() Finally, I updated views/example/index.html.erb to contain the following: views/example/index.html.erb <h3>Example Controller</h3>

<div data-controller="example"></div> <h3>Example Controller</h3>

<div data-controller="example"></div> At this point, the following URIs are now available: /jvc-utilities.html /example/index /jvc-utilities.html /jvc-utilities.html /example/index /example/index Let’s Deploy and Validate Rather than run the Rails service locally, I thought I would use Heroku instead. This way, I could make sure my service could be accessible for other consumers. Using my Heroku account, I followed the “ Getting Started on Heroku with Ruby ” guide. Based upon my project, my first step was to add a file named Procfile with the following contents: Getting Started on Heroku with Ruby Procfile web: bundle exec puma -C config/puma.rb web: bundle exec puma -C config/puma.rb Next, I used the Heroku CLI to create a new application in Heroku: heroku login
heroku create heroku login
heroku create With the create command, I had the following application up and running: create Creating app... done, ⬢ lit-basin-84681
https://lit-basin-84681-3f5a7507b174.herokuapp.com/ | https://git.heroku.com/lit-basin-84681.git Creating app... done, ⬢ lit-basin-84681
https://lit-basin-84681-3f5a7507b174.herokuapp.com/ | https://git.heroku.com/lit-basin-84681.git This step also created the Git remote that the Heroku ecosystem uses. Now, all I needed do was push my latest updates to Heroku and deploy the application: git push heroku main git push heroku main With that, my code was pushed to Heroku, which then compiled and deployed my application. In less than a minute, I saw the following, letting me know that my application was ready for use: remote: Verifying deploy... done.
To https://git.heroku.com/lit-basin-84681.git
   fe0b7ad..1a21bdd  main -> main remote: Verifying deploy... done.
To https://git.heroku.com/lit-basin-84681.git
   fe0b7ad..1a21bdd  main -> main Then, I navigated to the /example/index page using my Heroku URL (which is unique to my application, but I have since taken it down): https://lit-basin-84681-3f5a7507b174.herokuapp.com/example/index /example/index https://lit-basin-84681-3f5a7507b174.herokuapp.com/example/index This is what I saw: And when I viewed the JavaScript console in my browser, the following logs appeared: Navigating to /jvc-utilities.html , I saw the following information: /jvc-utilities.html When I viewed the JavaScript console in my browser, I saw the the following logs: Success. I was able to use a self-contained JavaScript library and also the public Lodash JavaScript library in my Rails 7 application—all by using Import Maps and without needing to deal with Webpack or Node.js. Buh-bye, Webpack and Node.js! Conclusion My readers may recall my personal mission statement, which I feel can apply to any IT professional: “Focus your time on delivering features/functionality that extends the value of your intellectual property. Leverage frameworks, products, and services for everything else.” — J. Vester “Focus your time on delivering features/functionality that extends the value of your intellectual property. Leverage frameworks, products, and services for everything else.” — J. Vester In this article, I dove head-first into Rails 7 and used Import Maps to show how easily you can use JavaScript libraries without the extra effort of needing to use Webpack and Node.js. I was quite impressed by the small amount of time that was required to accomplish my goals despite it being over two decades since I had last seen Rails in action. From a deployment perspective, the effort to deploy the Rails application onto the Heroku platform consisted of the creation of a Procfile and three CLI commands. Procfile In both cases, Rails and Heroku adhere to my mission statement by allowing me to remain laser-focused on delivering value to my customers and not get bogged down by challenges with Webpack, Node.js, or even DevOps tasks. While I am certain we will continue to face not-so-ideal pain points when exploring new technologies, I am also confident that in time, we will see similar accomplishments as I demonstrated in this article. As always, my source code can be found on GitLab here . here Have a really great day!

Buh-Bye Webpack and Node.js, Hello Rails and Import Maps

Buh-Bye Webpack এবং Node.js, Hello Rails এবং Import Maps

Tschüß Webpack und Node.js, hallo Rails und Import Maps

Buh-Bye Webpack y Node.js, Hello Rails e Importar mapas

Buh-Bye Webpack et Node.js, Hello Rails et Import Maps

अलविदा वेबपैक और नोड.जेएस, नमस्ते रेल्स और इम्पोर्ट मैप्स

さようなら Webpack と Node.js、こんにちは Rails と Import Maps

이제 안녕 Webpack 및 Node.js, Hello Rails 및 가져오기 맵

Buh-Bye Webpack e Node.js, Hello Rails e Import Maps

Прощайте, Webpack и Node.js, Hello Rails и импорт карт

Buh-Bye Webpack ve Node.js, Hello Rails ve İçe Aktarma Haritaları

Buh-Bye Webpack và Node.js, Hello Rails và Nhập bản đồ

告别 Webpack 和 Node.js，迎接 Rails 和 Import Maps

A Simplified Guide for the"Dockerazition" of Ruby and Rails With React Front-End App 

রিঅ্যাক্ট ফ্রন্ট-এন্ড অ্যাপ সহ রুবি এবং রেলের "ডকেরাজিশন" এর জন্য একটি সরলীকৃত গাইড 

Eine vereinfachte Anleitung zur „Dockerazition“ von Ruby und Rails mit der React Front-End-App

Una guía simplificada para la "Dockerazition" de Ruby y Rails con la aplicación React Front-End 

Un guide simplifié pour la « Dockerazition » de Ruby et Rails avec l'application React Front-End 

रिएक्ट फ्रंट-एंड ऐप के साथ रूबी और रेल्स के "डॉकराज़िशन" के लिए एक सरलीकृत गाइड

React フロントエンド アプリを使用した Ruby と Rails の「Docker 化」の簡易ガイド

React 프런트엔드 앱을 사용한 Ruby 및 Rails의 "Dockerazition"에 대한 단순화된 가이드 

Um guia simplificado para o "Dockerazition" de Ruby e Rails com o aplicativo React Front-End 

Упрощенное руководство по «докеразии» Ruby и Rails с помощью внешнего приложения React 

React Front-End Uygulaması ile Ruby ve Rails'in "Dockerazition"u için Basitleştirilmiş Bir Kılavuz 

Hướng dẫn đơn giản hóa về "Dockerazition" của Ruby và Rails với ứng dụng React Front-End 

使用 React 前端应用程序对 Ruby 和 Rails 进行“Dockerazition”的简化指南

Imagine an industry that has seen little innovation since the Civil War. It may seem unbelievable, but the United States railroad infrastructure is still the same as it was back in the original era. Taking on the industry to improve and plan for the future is Evertrak -- ready for a railroad infrastructure revolution. The company's mission is bold: replace traditional wooden railroad ties with cutting-edge, sustainable alternatives made from recycled plastics. Evertrak is addressing environmental concerns and industry challenges head-on. \Tim Noonan, CEO of Evertrak, doesn’t mince words: “It’s 2024!” he emphasizes. “We can do better. We must do better.” His vision of “the railroads of our Nation rolling on ties made from recycled plastics” isn’t just about sustainability—it’s about transforming an industry stuck in the past and solving real problems. Evertrak's journey began with a revolutionary idea: What if the plastic waste choking our planet could become the foundation of our transportation infrastructure? The team realized the industry needed more than just a new product—it needed a paradigm shift. “Our insight was that the industry needed a tie that was as strong as wood, not as cheap as wood,” Noonan explains. “We’re not offering a band-aid. We’re providing a solution for a real problem in the industry.” Addressing Industry Challenges Safety and efficiency are paramount in the railroad industry. With the adoption of Precision Schedule Railroading (PSR), which focuses on moving individual cars rather than waiting for long trains to be built, uptime has become more critical than ever. Evertrak’s ties directly address this need and offer a redefinition of what’s possible in railroad operations. “Using our tie, railroads won't have to replace ties in high decay zones every 8-12 years,” says Noonan. “This means better uptime for PSR and lower total cost of ownership.” Sustainability Impact Experts suggest only 9% of plastic waste is effectively recycled globally. And industry estimates for North America alone suggest 20 million wooden railroad ties are replaced annually—equivalent to approximately 6 million trees. As Noonan mentioned, with an average lifespan of around a decade (reduced to just 5 years in high-rot regions), the environmental impact of current railroad practices is significant and the environmental benefits of Evertrak's ties are clear. By using recycled plastics, Evertrak not only diverts hundreds of thousands of pounds of waste from landfills but also prevents deforestation and avoids the CO2 produced when traditional ties are incinerated or landfilled at the end of their life. “This is just the beginning,” Noonan promises, explaining that the industry replaces more millions of wood ties a year. For Noonan and Evertrak, it’s about securing a livable planet for future generations. “Imagine that many trees saved. Imagine millions of pounds of plastic put to better use and removed from our landfills and oceans. Every tie we produce is a blow against deforestation and plastic pollution.” Union Pacific’s commitment to alternative railroad ties strikes Noonan as a resounding endorsement of this important industry shift, and the CEO sees it as a rallying cry: “UP is the de facto leader of the railroad industry. Their measured implementation of our ties builds trust and confidence for others. I think the message is: It’s time to get on board.” Industry Veterans Signal Transformation One of the most promising signs of Evertrak’s potential to revolutionize the railroad industry is the company’s ability to attract respected executives who have historically been on the wood tie side of the business. “Yes, it really signals disruption in the industry,” Noonan explains. “These executives understand that the Class 1 railroads do not have alternatives when it comes to ties. They understand the business practices and products that keep things going between big creosote and the railroads.” This insider knowledge is proving invaluable as Evertrak seeks to transform the industry. With the never-ending rise of single-use plastic and the detrimental impact of deforestation, Noonan believes there's room for improvement. “We can do better,” he asserts. “I've been speaking with a number of industry veterans who believe that the time is right for transformation.” The involvement of these industry veterans not only lends credibility to Evertrak’s mission but also suggests that the railroad industry as a whole might be gearing up for a significant shift towards more sustainable practices. Future of Sustainable Infrastructure in Railroads Evertrak’s highest priority is continuing to build trust with Class 1 customers, bringing awareness to one of America’s oldest industries—some of the first tracks were laid nearly 200 years ago—so they have the resources and support to join the modern era. The company’s goals are ambitious: save millions of trees, drastically reduce plastic buildup, and do it all now. Evertrak’s approach is collaborative, empowering the customer to dictate success through communication and keeping commitments. “We have 7 years of proven results,” Noonan says. “And that includes never missing a delivery timeline. To date, we’ve installed over 100,000 composite ties with zero claims.” For other companies looking to innovate with sustainable materials, Noonan offers this advice: “Identify a pain point and make that pain go away for the customer. Your customer doesn’t care that the product is made from sustainable material; they want their problem to go away. Deliver the business case, and the case for sustainability comes along to close the deal.” As the railroad industry grapples with the need for more sustainable practices, companies like Evertrak are proving that environmental responsibility and business efficiency can go hand in hand. By addressing real industry pain points with innovative, sustainable solutions, Evertrak is helping to lay the tracks for a sustainable future in transportation infrastructure. The implications of this shift are far-reaching, potentially influencing other sectors of the transportation industry. As Noonan puts it, "If a pain point in the business can be solved through a sustainable solution, I believe the industry can have the business case and the benefit of sustainability without a tradeoff." With industry leaders like Union Pacific embracing these innovations, it's clear that the future of railroad infrastructure isn’t about maintaining the status quo—it’s about revolutionizing it for a more sustainable, efficient tomorrow. In Noonan’s words, “It’s time for the railroad industry to declare its independence from wood ties and creosote. Join us in this revolution! We’re not just making ties—we’re making history.” Imagine an industry that has seen little innovation since the Civil War. It may seem unbelievable, but the United States railroad infrastructure is still the same as it was back in the original era. Taking on the industry to improve and plan for the future is Evertrak -- ready for a railroad infrastructure revolution. The company's mission is bold: replace traditional wooden railroad ties with cutting-edge, sustainable alternatives made from recycled plastics. Evertrak is addressing environmental concerns and industry challenges head-on. Evertrak Evertrak \Tim Noonan, CEO of Evertrak, doesn’t mince words: “It’s 2024!” he emphasizes. “We can do better. We must do better.” His vision of “the railroads of our Nation rolling on ties made from recycled plastics” isn’t just about sustainability—it’s about transforming an industry stuck in the past and solving real problems. “It’s 2024!” he emphasizes. “We can do better. We must do better.” His vision of “the railroads of our Nation rolling on ties made from recycled plastics” isn’t just about sustainability—it’s about transforming an industry stuck in the past and solving real problems. must sustainability—it’s about transforming an industry stuck in the past and solving real problems. Evertrak's journey began with a revolutionary idea: What if the plastic waste choking our planet could become the foundation of our transportation infrastructure? The team realized the industry needed more than just a new product—it needed a paradigm shift. “Our insight was that the industry needed a tie that was as strong as wood, not as cheap as wood,” Noonan explains. “We’re not offering a band-aid. We’re providing a solution for a real problem in the industry.” Addressing Industry Challenges Addressing Industry Challenges Safety and efficiency are paramount in the railroad industry. With the adoption of Precision Schedule Railroading (PSR), which focuses on moving individual cars rather than waiting for long trains to be built, uptime has become more critical than ever. Evertrak’s ties directly address this need and offer a redefinition of what’s possible in railroad operations. “Using our tie, railroads won't have to replace ties in high decay zones every 8-12 years,” says Noonan. “This means better uptime for PSR and lower total cost of ownership.” Sustainability Impact Sustainability Impact Experts suggest only 9% of plastic waste is effectively recycled globally. And industry estimates for North America alone suggest 20 million wooden railroad ties are replaced annually—equivalent to approximately 6 million trees. As Noonan mentioned, with an average lifespan of around a decade (reduced to just 5 years in high-rot regions), the environmental impact of current railroad practices is significant and the environmental benefits of Evertrak's ties are clear. only 9% only 9% By using recycled plastics, Evertrak not only diverts hundreds of thousands of pounds of waste from landfills but also prevents deforestation and avoids the CO2 produced when traditional ties are incinerated or landfilled at the end of their life. “This is just the beginning,” Noonan promises, explaining that the industry replaces more millions of wood ties a year. For Noonan and Evertrak, it’s about securing a livable planet for future generations. “Imagine that many trees saved. Imagine millions of pounds of plastic put to better use and removed from our landfills and oceans. Every tie we produce is a blow against deforestation and plastic pollution.” that millions Union Pacific’s commitment to alternative railroad ties strikes Noonan as a resounding endorsement of this important industry shift, and the CEO sees it as a rallying cry: “UP is the de facto leader of the railroad industry. Their measured implementation of our ties builds trust and confidence for others. I think the message is: It’s time to get on board.” Industry Veterans Signal Transformation One of the most promising signs of Evertrak’s potential to revolutionize the railroad industry is the company’s ability to attract respected executives who have historically been on the wood tie side of the business. “Yes, it really signals disruption in the industry,” Noonan explains. “These executives understand that the Class 1 railroads do not have alternatives when it comes to ties. They understand the business practices and products that keep things going between big creosote and the railroads.” “Yes, it really signals disruption in the industry,” Noonan explains. “These executives understand that the Class 1 railroads do not have alternatives when it comes to ties. They understand the business practices and products that keep things going between big creosote and the railroads.” This insider knowledge is proving invaluable as Evertrak seeks to transform the industry. With the never-ending rise of single-use plastic and the detrimental impact of deforestation, Noonan believes there's room for improvement. “We can do better,” he asserts. “I've been speaking with a number of industry veterans who believe that the time is right for transformation.” The involvement of these industry veterans not only lends credibility to Evertrak’s mission but also suggests that the railroad industry as a whole might be gearing up for a significant shift towards more sustainable practices. Future of Sustainable Infrastructure in Railroads Evertrak’s highest priority is continuing to build trust with Class 1 customers, bringing awareness to one of America’s oldest industries—some of the first tracks were laid nearly 200 years ago—so they have the resources and support to join the modern era. The company’s goals are ambitious: save millions of trees, drastically reduce plastic buildup, and do it all now. Evertrak’s approach is collaborative, empowering the customer to dictate success through communication and keeping commitments. “We have 7 years of proven results,” Noonan says. “And that includes never missing a delivery timeline. To date, we’ve installed over 100,000 composite ties with zero claims.” zero For other companies looking to innovate with sustainable materials, Noonan offers this advice: “Identify a pain point and make that pain go away for the customer. Your customer doesn’t care that the product is made from sustainable material; they want their problem to go away. Deliver the business case, and the case for sustainability comes along to close the deal.” As the railroad industry grapples with the need for more sustainable practices, companies like Evertrak are proving that environmental responsibility and business efficiency can go hand in hand. By addressing real industry pain points with innovative, sustainable solutions, Evertrak is helping to lay the tracks for a sustainable future in transportation infrastructure. The implications of this shift are far-reaching, potentially influencing other sectors of the transportation industry. As Noonan puts it, "If a pain point in the business can be solved through a sustainable solution, I believe the industry can have the business case and the benefit of sustainability without a tradeoff." With industry leaders like Union Pacific embracing these innovations, it's clear that the future of railroad infrastructure isn’t about maintaining the status quo—it’s about revolutionizing it for a more sustainable, efficient tomorrow. In Noonan’s words, “It’s time for the railroad industry to declare its independence from wood ties and creosote. Join us in this revolution! We’re not just making ties—we’re making history.”

Stories, News & Mentions about RAIIL

Categories

Trending Topics

Stories, News & Mentions about RAIIL

Raiil’s Stories on HackerNoon

Raiil's News & Mentions

Categories

Trending Topics