Fortis, one of Canada's largest gas utilities, has laid out its vision for survival in a world that is moving away from fossil fuels — use more gas.

Decarbonization the latest buzzword from gas companies | Canada's National Observer: Climate News

Fortis is down 15% from the 12-month high. Time to buy? The post Fortis Stock: Buy, Sell, or Hold Today? appeared first on The Motley Fool Canada.

Fortis Stock: Buy, Sell, or Hold Today?

Forta is clearing the path to quality healthcare by delivering the best possible outcomes with the utmost convenience

Forta

I recently spoke with Andrew Beal, the spokesperson of , on Web3 security, the rise in DeFi hacks, and where blockchain protocols are going wrong. Forta Q: Welcome, Andrew. Before getting into specifics, can you give us an overview of the Web3 industry’s security infrastructure. Hey, thanks for having me. So in terms of security infrastructure, let’s partition this discussion. There’s smart contract security, and there’s traditional Web 2 security, and teams need to invest in both. I break smart contract security up in two buckets - pre-deployment security and post-deployment security. Before you deploy your smart contracts, you should leverage templates to the extent possible, and get multiple, independent code audits. After you deploy, it’s common practice to put a bug bounty program in place to encourage white hats to identify vulnerabilities. The other two pillars of post-deployment security are real-time monitoring and alerting, and incident response. The Forta Network, for example, monitors on-chain activity in real-time for threats and anomalies, but there is a close relationship between the alerts emitted by Forta and the incident response function. Alerts are only helpful if teams can timely respond to them. You also can’t forget about the Web 2 components - every project has to secure their website, emails accounts, private keys, physical infrastructure, etc. A lot of hacks are the result of poor security practices in these areas. We see a lack of understanding and an underinvestment from teams across the board.  If you look at the , hackers . In absolute numbers, losses rose by 79% from 2020. Now we think most of these attacks were preventable. data from Chainalysis stole $14 billion in 2021 Q: Why do you say these Web3 attacks and hacks are preventable? Can you explain why some Web3 protocols fail to prevent these attacks in some instances? First, a lot of hacks occur because teams aren’t following best practice with respect to their “Web 2 components” - private key management, account security, access controls, etc. There’s nothing Web 3 about these, and simply following best practice would have prevented them. Second, there’s a misconception that most smart contract exploits are atomic - meaning they occur in a single block. Over 50% of exploits actually occur over several blocks. We can dissect the anatomy of a Web3 attack into four phases, known as the “kill chain”. In the first stage (Funding), attackers gather funds to pay transaction fees for high-volume trades and accumulate collateral for loans. In the second stage (Preparation), attackers often deploy special smart contracts used to carry out the attack. In the third stage (Exploitation), hackers execute the attack by draining funds from smart contracts or user’s wallets. And finally, in the fourth stage (Money Laundering), attackers launder stolen proceeds through privacy protocols like Tornado Cash. If you identify an exploit attempt early enough in the kill chain, you have an opportunity to prevent it. Today, the only means of prevention are either pausing the protocol, or frontrunning the malicious transaction. In the future, we expect there to be more mechanisms for incident response, which may include things like transaction simulations, and user and contract reputation systems. Q: What is the modus operandi of Forta? How does Forta prevent Web3 attacks? Forta is a decentralized network for monitoring, detecting, and alerting users about potential threats and anomalies. Forta monitors and protects over $36 billion across Ethereum, Polygon, Binance Smart Chain, Arbitrum, Optimism, Avalanche, and Fantom. We have a vast network of executing over 1,000+ Detection Bots to monitor, alert, and prevent Web3 attacks. 12,000+ Scan Nodes There are two primary components to the Forta Network - bots and scan nodes. Bots are pieces of code that act like little virtual security cameras, monitoring something specific on-chain. Scan nodes are like the alarm system behind the scenes that run the bots against each block of transaction. If a bot finds what it’s looking for in a block, the node running that bot emits a public alert. Forta’s role in attack prevention is to detect threats and other malicious activity as early as possible. By alerting our users as early as possible, they have an opportunity to take preventative action. Q: Can you elaborate on some of Forta's techniques for preventing Web3 attacks? How are Forta’s monitoring systems different from other monitoring protocols in the market? The Forta developer community has built bots leveraging a variety of techniques to monitor and detect threats. One of these techniques is Attack Simulation. The bot simulates an attack, mimicking the exploit transaction locally before it happens on-chain. Another strategy used is Time Series Analysis, where Bots map historical data variance within a fixed time frame. This helps create a ‘normal range’ and bandwidth within which the data can fluctuate without generating any alerts. However, when the value deviates from the expected range, the bot generates an alert. Time series analysis provides efficient threat detection, as it can ignore routine spikes and variabilities. More and more bots are also using data science and machine learning techniques.. For example, our uses the ML algorithm to identify abnormal transaction activity for ERC-20 token transfers. Similarly, bots use the to create clusters and label wallet addresses based on transaction activity. Anomalous Token Transfers Detection Bot Isolation Forest StackingClassifier Q: How do you envision the future of Web3 security? Will Web3 attacks cease to exist with the emergence of security and monitoring networks? The answer to your second question is no; attacks won’t go away. In fact, they will evolve and get more sophisticated over time. Our detection and prevention techniques will also improve. This is the nature of any adversarial environment. To your first question around the future of Web 3 security, I think it requires a combination of upfront prevention and real-time detection. There are things we can do up front to identify bad actors and malicious transactions, such as requiring transactions above a certain dollar amount to be simulated before they are broadcast and included in a block. At some point in the future, I expect we’ll have better on-chain reputation systems for both users and EOAs, which should make it easier to identify suspicious actors and contracts. In conjunction with upfront prevention, teams should also be investing in real-time detection capabilities, because no matter how hard you try, you won’t be able to prevent every single attack.

Discussing Web3 Security with Forta Ecosystem Lead Andrew Beal 

I recently caught up with William Simonin, Chairman at , which leverages global crowdsourcing to collect and validate diverse data types for AI model training. In our conversation, we discussed the nuances of AI’s challenges and how we can overcome them. Hope you enjoy. Ta-da Welcome, William. Let’s begin with your origin story. Thanks for inviting me. I'm William Simonin, a French entrepreneur and co-founder of some companies in AI, tech, and cryptocurrency. Ta-da comes from Vivoka, our voice recognition and AI company. Today, we're one of Europe's leaders. We specialize in speech recognition and create AI models for our voice assistants using machine learning. The problem arises when we need big data to train new language models as languages evolve. Unfortunately, this is not an easy task, with agencies providing us with mediocre data and open-source solutions not always up to the job. Looking back, we realized it's not just a problem in speech recognition but in many areas (computer vision, content management, etc.). That's why we launched Ta-da! Our aim with Ta-da is to give companies making AI models the best data while making sure contributors get paid fairly. We want to connect high-quality data with the needs of exciting AI projects! How do you address ‘AI is a monster, here to take our jobs away’ narratives? Regarding the notion that artificial intelligence could become a monster devouring all human jobs, we adopt a perspective that views AI as a major technological advancement, akin to the advent of computers or the internet. Our conviction is that AI's aim is not to replace jobs but rather to fundamentally transform how we work by introducing innovative tools. We anticipate that AI will alleviate tedious tasks for workers while preserving essential human values such as creativity and consciousness. This inevitable transformation will have a significant impact across various sectors, from journalism to communication, writing, and many others. We view this evolution as an opportunity to rethink and improve our daily work methods. It's crucial to emphasize that the tool itself is neutral, and its benevolent use depends on human decisions. Our ultimate goal is to adopt this technology responsibly, ensuring it contributes to enhancing daily life while respecting fundamental human values. Now, focusing inward, what are the biggest challenges and problems in the AI space today? Currently, we are facing two major challenges in the field of artificial intelligence. Firstly, on a technical level, we have overcome numerous hardware constraints such as processor speed, bandwidth, and memory capacity for AI. However, one major obstacle persists in the realm of AI training, where ensuring quality remains a significant challenge, and for this, data is essential. Secondly, we are tackling the crucial challenge of intellectual property. The issue of intellectual property arises during the AI training process, where multiple contributors may collaborate in developing a solution. Managing intellectual property then becomes a central concern, and we are exploring innovative approaches such as using technologies like blockchain to ensure fair attribution of created value. Security and data privacy, as well as appropriate intellectual property management, are crucial aspects of our approach to overcoming these initial obstacles in the field of AI. Tell us more about your vision for Ta-da. Sure. Our vision for Ta-da is based on several strategic pillars aimed at demonstrating the real impact of our approach on how artificial intelligence companies aggregate and utilize data. We believe our challenge will be fully met when we become the preferred provider for the world's largest corporations. Subsequently, we aim to revolutionize the microtasking domain through Ta-da, positioning our platform as an indispensable reference point. Our goal is to establish a new standard in this sector by offering innovative and efficient solutions. Simultaneously, we aim to shed light on the reality of blockchain and create a global community based on the principle of meritocracy. This approach aims to establish total transparency and promote fair collaboration within our ecosystem. In summary, our vision for Ta-da encompasses the transformation of the microtasking landscape, the establishment of privileged partnerships with major corporations, and the creation of a global community based on the values of blockchain and meritocracy. What’s next for Ta-da and AI? The next phase for Ta-da holds promise, with ambitious goals to achieve. Our top priority is to demonstrate the true value of blockchain by disrupting established systems. We aim to fully leverage this revolutionary technology to transform business practices, ensuring complete transparency and enhanced data security. Simultaneously, we are committed to advancing our application reliably and swiftly, to make our solutions accessible as soon as possible. Our primary objective is to provide a robust and high-performing platform, meeting the needs of our users with unparalleled quality. Additionally, we strive to make the entire Ta-da process accessible to everyone, regardless of the size or skill level of the organization or individual. We seek to popularize our concepts and tools to make them usable by all. Finally, we aim to build a strong global community by promoting the values of meritocracy and transparency. By rallying individuals around our vision, we can create a positive and lasting impact in the fields of artificial intelligence and microtasking.

Crowdsourcing AI Training Data — A Discussion With William Simonin, Ta-da Chairman

**USA / CALIFORNIA, March 7th, 2024/Chainwire/--**Firewall secures funding from North Island Ventures, Breyer Capital, and Hack VC to bulletproof smart contract networks. Firewall, a blockchain infrastructure startup, announced its $3.7M pre-seed round, co-led by , , and . Firewall transforms the usability of smart contract technology through an innovative finality consensus mechanism that eliminates smart contract exploits. North Island Ventures Breyer Capital Hack VC The founders of Firewall, previously the first and sixth employees at —a staking company acquired by Kraken in a landmark crypto deal—have helped breathe life into the eras of proof-of-stake and decentralized finance over the last six years. Staked In that time, the founders served institutional clients with infrastructure that handled billions of dollars, and now building on their experience, are addressing what most perceive as the final major hurdle to a full embrace of digital assets by the traditional financial system. “Firewall is building the safety rails that enable the everyday person to use the next era of the Internet,” stated , Co-Founder of Firewall. Devan Purhar “Today, billions of dollars are stolen from users, through irreversible transactions that are classifiable as theft. There’s a parallel between the current state of crypto-networks and the early internet, with a similar lack of essential security infrastructure. Our focus is not on marginal improvements; rather, we bring a required paradigm shift in the usability of blockchains. We designed a solution from first principles, and created programmable finality. Fundamentally, we make exploits a concept of the past.” Akin to a digital version of a traditional network’s firewall, Firewall’s technology introduces "programmable finality”. It extends rollups to use programmable transaction finalization rules, which act as automated checkpoints that block harmful transactions, inserted before later stages when the data is finalized by a DA layer such as EigenDA or Celestia. The founders envision Firewall as a part of every smart contract network, acting as an embedded security system that intelligently guards against threats. "Firewall uses real-time algorithms to pre-filter exploits from being included in blocks," shared , Firewall Co-Founder. Sam Mitchell "Then, by using programmable finality we automatically recover from any exploits that bypass the pre-filter checks. Detection at this stage can involve AI models or social consensus, which may take longer.” Mitchell emphasized that institutions, managing trillions in assets, are interested in the benefits of smart contracts but require a secure environment to deploy capital. “Creating comfort for institutional clients to use smart contracts will be the pivotal point for the widespread adoption of digital assets.” Past the founders, the core team is credited with successfully pioneering AI use in crypto threat detection at OpenZeppelin and Forta, and is set to revolutionize the field with Firewall's all-encompassing security approach. The startup’s initial focus is on the rollup ecosystem, and prides itself on alignment with building non-custodial and trustless solutions. The funding will help expand the team and create the community to “firewall the EVM”. Longer-term plans include developing coordination mechanisms to integrate the social layer directly into the Firewall. Travis Scher, Managing Partner at North Island Ventures, said “We believe the primary impediment to crypto’s mainstream adoption is the current security paradigm, in which a single bug can lead to a total loss of user funds. Firewall's solution can prevent such losses, and we are thrilled to support such an important company from the outset.” The funding round was co-led by North Island Ventures, Breyer Capital, and Hack VC, with participation from Finality Capital, and angels including Tim Ogilvie of Staked, Kain Warwick and Jordan Momtazi of Synthetix, Nathan McCauley of Anchorage, and Yaoqi Jia of AltLayer. “Firewall is making blockchains safer for users, developers, and institutions,” said Ted Breyer of Breyer Capital. “We see this catalyzing a new era of smart contract utility, and we’re delighted to support the team.” With the growing global adoption of crypto and regulatory spotlight, catalyzed by the BTC ETF and anticipated ETH ETF, the time for crypto-networks to become bulletproof is now. Trillions of dollars remain on the sidelines, scared to use smart contracts. Firewall's “programmable finality” which effectively neutralizes exploits, offers the security assurance needed to unlock these assets, paving the way for crypto to revolutionize the global financial system. About Firewall is dedicated to making smart contract technology safe to use in everyday life, by eliminating smart contract exploits. Their solution is akin to a robust network firewall, applied to the modular blockchain ecosystem. Firewall Contact Co-Founder Devan Purhar Firewall devan@usefirewall.com This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here.

Firewall Raises $3.7M To Take Smart Contracts Mainstream With Programmable Finality

Crypto promised to be secure and immutable, so why Is hacking commonplace? As most know by now, crypto is short for cryptography, so it must already be secure, right? But the fact is that thefts are a routine occurrence as a result of hacks and attacks. Cyberattackers made off with worth of crypto in 2023, and not mincing any words, was a discussion topic at the TechCrunch Disrupt event in September. $2 billion “Why is Web3 Such a Cybersecurity Disaster?” Yet crypto’s proponents still to the fact that platforms like Bitcoin and Ethereum are secure against attackers and use phrases like “not your keys, not your crypto” to espouse the view that self-custody is the best protection against theft or censorship. point While the numbers tell a clear story, crypto’s supporters aren’t simply being disingenuous when they talk about the security of blockchain. The networks that operate Bitcoin and Ethereum have always proven to be resilient against attacks. But due to the immaturity of the industry and a lack of rigor in cybersecurity operations, the applications built on and for these networks frequently prove to be far more vulnerable than the underlying infrastructure. In the absence of universal standards or regulations, the industry needs to find the will to raise the bar. The Changing Landscape of Blockchain Attacks In a blockchain network, the first security defense is its encryption. Transactions are encrypted, decentralized, and stored in blocks that are linked cryptographically, creating an immutable chain. So far, no one has managed to interrupt the biggest chains by inserting fake transactions. Users can only authorize a transaction by entering their unique private key. However, since users are fallible humans, for many years, the first line of attack for hackers was discovering private keys through methods such as phishing and malware. Cyberattackers always target the biggest rewards for the least risk or effort, and so key-holding employees at centralized exchanges became the earliest targets. From 2017 onwards, Ethereum became a hub of activity for smart contracts and decentralized applications, allowing anyone to create code that governs cryptocurrency or programmable money. The explosion of innovation created many use cases for cryptocurrencies that the world began to see in 2021 in what became known as ‘DeFi’ applications. This on-chain liquidity created a new bull run and began to flow through DeFi protocols and bridges that connect otherwise unconnected blockchain ecosystems. Unfortunately, since every one of these protocols is based on code, which is also written by fallible humans, this innovation opened up a whole new set of attack vectors for hackers. , the percentage of all cryptocurrency stolen using DeFi protocols rose from 30% in 2020 to 97% in the first quarter of 2022. According to Chainalysis data By the second quarter of the same year, Chainalysis had become the biggest security risk facing the industry. The amounts involved in bridge and DeFi exploits can be eye-wateringly high – stolen in the 2022 DPRK hack of the Ronin bridge. Even in the down markets of 2023, a single attack can result in losses of , as users of Mixin Network found out. announced that cross-chain bridges $600 million up to $200 million So who’s to blame? What makes this segment such a honeypot for hackers? While the risk-reward ratio is similar to centralized exchanges, DeFi also offers the allure of pseudonymity and permissionless access, with proceeds available immediately for a liquid exit. Furthermore, the decentralized environment means that users are often flying blind, navigating a poor user experience where glitches are commonplace and there is no recourse for clicking the wrong button in error. However, a far more significant problem is the relative lack of maturity in the sector when it comes to cybersecurity. When coding Turing-complete languages such as Solidity, it’s still very easy to program in bugs, or it may be possible that the code allows for unanticipated outcomes that can be exploited by attackers. Although things have improved somewhat over recent years, there are still no best practices when it comes to protocol security and audits to identify and eliminate these issues. Many DeFi projects now engage third-party code auditors in an attempt to root out bugs and security issues, and some also operate bug bounties to encourage indie developers and white-hat hackers to support their efforts to maintain clean code. The lack of uniform standards and the complexity of technology means the average person can't be sure how effective a security audit really is. Plus, not all audits are equally reliable. The best auditors often have long waitlists, leading to newer auditors filling in the gap. This can be risky because protocols might end up with a low-quality audit and not realize it until a hacker finds a weakness. For those handling large amounts of user funds, getting a top-notch audit is crucial but often not feasible due to these challenges. Raising the Bar While industry-wide teething problems explain the issues to a certain extent, it’s impossible to ignore the elephant in the room – an overall lack of rigor that’s applied to Web3 protocols compared to their Web2 counterparts. Robust cybersecurity operations almost always incorporate an element of monitoring, where suspicious activity can be flagged, investigated, and, in many cases, averted via automated incident response before a hack occurs. Projects like Forta, Tenderly, and Hypernative have all sprung up to fill this gap in the market. However, the tools that have been developed for centralized systems are generally unfit for purpose in a decentralized environment. After all, intrusion detection has little use where access is permissionless by design. But things are changing. The publicly available nature of blockchain data combined with the power of machine learning means that it is possible to monitor and detect threats on blockchain-based protocols in real time. By harnessing a decentralized network of bots, each dedicated to monitoring either generic threats or protocol-specific activity, it’s possible to garner a tremendous amount of threat intelligence data, which can then be consumed by users or developers. In most cases, it would be possible to shut down operations and stave off a threat before it becomes an incident. The availability of Web3 monitoring tools and their efficacy in detecting attacks in advance before any funds get stolen are now sufficiently developed such that they can and should become an industry standard. Furthermore, this should be prioritized as one of the most significant leaps forward in cybersecurity that the industry can make in the coming years. Although hackers will invariably find the next vulnerability, cutting the current lines of attack off from the source will make DeFi a significantly safer place for its beleaguered users.

Is Crypto (In)Secure?

132 Stories To Learn About Information Security

Map of the Internet I recently expanded on my Internet map visualization that showed all of the undersea internet cables that run along the bottom of the oceans and seas. This time, I also added dots that represent the locations of all of the advertised internet exchanges in the world. The brighter/greener/bigger the dot, the more bandwidth the internet exchange supports. What’s an internet exchange? Internet Exchange: An Internet exchange, often referred to as an Internet Exchange Point (IXP), is a physical infrastructure or facility where Internet Service Providers (ISPs) and other network operators connect their networks together to exchange Internet traffic. The primary purpose of an internet exchange is to improve the efficiency of data exchange between different networks by allowing direct peering between them. Instead of sending data through multiple third-party networks, which can lead to increased latency and costs, ISPs can directly exchange traffic at an internet exchange, resulting in faster and more cost-effective data transmission. Internet exchanges play a crucial role in the functioning of the global internet. By facilitating direct peering, they help reduce the reliance on expensive long-distance links and enhance the overall performance and resilience of the internet. They also promote competition among ISPs and encourage the growth of internet infrastructure in specific regions. Traceroute Command: The command is a network diagnostic tool used to trace the route that data packets take from one computer to another across a network, typically the Internet. It helps identify the network path taken by the data, showing the sequence of intermediate devices (routers) that the packets pass through before reaching the destination. traceroute $ sudo mtr apple.com
                            My traceroute  [v0.95]
kevins-mbp-m1.local (192.168.88.31) -> apple.com (17.22023-08-02T13:19:54+0200
Keys:  Help   Display mode   Restart statistics   Order of fields   quit
                                      Packets               Pings
 Host                               Loss%   Snt   Last   Avg  Best  Wrst StDev
 1. router.lan                       0.0%     5    5.2   4.8   4.3   5.2   0.4
 2. 10.24.0.1                        0.0%     4    4.7   4.6   4.3   5.0   0.3
 3. soeborg2.net.gigabit.dk          0.0%     4    5.6   6.6   5.5   9.7   2.1
 4. apple-1.equinix-am1.nl-ix.net    0.0%     4   15.6  15.5  14.1  16.6   1.0
 5. apple.com.sg                     0.0%     4   15.2  15.0  14.5  15.6   0.5 In the provided example output: is the name of the source host or the computer from which the is initiated. That’s my laptop, so I know that it is located in Copenhagen, Denmark. kevins-mbp-m1.local traceroute is the destination host or the target server to which the is being performed. apple.com traceroute The columns in the output represent the following information: : The intermediate routers or nodes in the network path. Host : The percentage of packet loss experienced while reaching each router. Loss% : The number of packets sent to each router. Snt : The last round-trip time taken to reach the router. Last : The average round-trip time to reach the router. Avg : The best (minimum) round-trip time to reach the router. Best : The worst (maximum) round-trip time to reach the router. Wrst : The standard deviation of round-trip times to the router. StDev Identifying Exchange Location using Reverse IP Lookup: In the output, you can sometimes infer the location of an internet exchange based on the names of the intermediate routers. Many internet exchanges are named explicitly to indicate their location. For example, in the provided , the router with the name suggests that it is associated with Equinix Amsterdam (AM1), which is a prominent internet exchange in Amsterdam, Netherlands. traceroute traceroute apple-1.equinix-am1.nl-ix.net However, it’s important to note that not all routers or nodes in a traceroute will have such descriptive names. Some routers might be labeled with IP addresses or generic names that do not reveal their location. In such cases, it becomes more challenging to pinpoint the exact location of an internet exchange solely based on the traceroute output. Additionally, the reverse IP lookup method depends on the accuracy and up-to-date information in the IP address registries, and some routers might not be accurately represented. Because of all of this, we can see the path that is taken when connecting to a server, which I think is really cool. With my example, I can know that it takes around 15.5 milliseconds for my network traffic to reach the Netherlands, and I can tell that Apple is peering directly in this facility. You can verify this fact by looking at . Essentially, if you want to load faster for your users who are near(ish) to Amsterdam, you may want to run some fiber optic cable to this internet exchange. Put another way, the closer you are to the dots, the closer you are to the internet. PeeringDB apple.com How it’s made First, this is where I got the data from: - PeeringDB is a user-driven database that offers information about network interconnection facilities and peering arrangements, supporting network administrators in optimizing Internet connectivity. PeeringDB - I used this dataset to geolocate all internet exchanges in PeeringDB using the city and country fields. Simple Maps - TeleGeography maintains a database of all major submarine fiber optic cables and their status. Submarine Cable Map Next, these are the different tools/languages that I used: Javascript (nodejs) - D3.js is a powerful JavaScript library for data visualization that allows developers to create interactive and dynamic charts, graphs, and other visual representations on the web using HTML, SVG, and CSS. D3 - library that helps with running d3 inside of a nodejs environment d3-node - library that handles translating coordinates for different map projections. I know it’s controversial now, but the earth isn’t flat. So to make a flat image you have to pick how you are going to translate the globe coordinates onto a map. Despite its flaws, I used the because it is by far the most popular map projection. d3-geo mercator projection - This is my current working language, so it’s what I used to integrate with the PeeringDB API and do some data processing/validation. The Go Programming Language - A library for talking to the PeeringDB API. PeeringDB The pipeline looks like this: Mapping of Cities to lat/long GPS coordinates I had so many data validation issues when doing this project. I should have expected this more since PeeringDB is user-managed, and there’s no validation of the City field. I had a lot of random issues mapping internet exchanges with their GPS coordinates. First, the geolocation database I was using was not complete. It only has around 43 thousand cities, but there are many, many more towns and cities. The way I handled that was to manually map to the closest city that I do have geo coordinates for. Additionally, the city field would be misspelled or formatted in a way differently than my database, or the name of the city may have changed. This happens a lot because there are usually multiple ways to convert many languages into Latin characters. And sometimes cities just change their names. All-in-all, I have 95 internet exchanges that I have had to manually map. I can’t guarantee that they are all correct… but it is definitely good enough. You can see all of the places that I manually mapped . on github Here are my favorites: There was an Internet Exchange named “BGP.Exchange - Los Angles.” Either they were talking about Los Angeles, or they just really like angles. - entry on PeeringDB (note: I believe they fixed the city entry but haven’t yet fixed the name of the IX) There is an exchange named “Example IX” which is obviously just used as an example: entry on PeeringDB The accepted Western name for the capital city of Ukraine changed from Kiev to Kyiv due to the efforts of a campaign called . There are several internet exchanges still using the old spelling in its address. KyivNotKiev Observations from the map Now here’s the pretty part. Here are close-ups of different parts of the map with some general observations. North America The internet exchanges in North America look how I’d imagine them. There are more and higher bandwidth internet exchanges on the eastern side of the US and a good amount along the west coast. However, there are some very important internet exchanges in Colorado. It likely serves as a good halfway point between East and West to transition traffic to different backbone providers. Europe After seeing the map from North America, it’s rather surprising to see how dense European internet exchanges are. There’s almost too much to comment on here, but I will say that it’s interesting how important Amsterdam, Frankfurt, and London are. Asia-Pacific The area around Asia looks rather crazy, but it’s important to note that fiber links can visit islands along the way in order to give them internet access. Those islands will have networking gear that ‘drops’ and ‘adds’ certain channels of the signal. The network device is typically a ROADM (reconfigurable optical add-drop multiplexer). I bet you can guess why they made that an acronym. Also, I think open peering in China is not really a thing, as I believe most traffic goes through so-called backbone providers instead of through internet exchanges. This is likely related to the . On the map, you only see a good number of internet exchanges in Hong Kong. great firewall of China Africa Africa has many optical cables that travel along coasts. I suspect the terrestrial optical networks aren’t as well developed in most parts of Africa. There are exceptions, though. There is a lot of bandwidth capacity in internet exchanges in Capetown and Pretoria. Also, it’s crazy to see how many optical cables lie at the bottom of the Suez canal. South America In South America, we have Fortaleza and Sao Paula have a lot of landings and internet exchanges. Svalbard Svalbard is a set of islands owned by Norway that is waaay far north. It’s one of those places that gets six months of day followed by six months of night. And it’s always super cold. It’s interesting to see two undersea cables to a place like this. Svalbard is where lives, with seeds from all over the world. If you want to use these two cables, you can check out . the global seed vault some webcams that are set up in Svalbard Maldives Maldives is another interesting place where fiber optic cables live. You might notice that the fiber optic cables cross each other. It appears that it was done in order to connect islands that the first cable didn’t service before. The cables were commissioned around five years apart. It must have been a hard five years if you lived on one of the islands that didn’t get high-speed internet in the first round. Thanks for reading So far, I’m pretty happy with the results of this little project. If I were to work more on this, I would want there to be an actual heatmap instead of just drawing dots. I have attempted to do this, but it was taking too long to figure out how to properly do it, specifically with the node-d3 library. Also, there’s probably a lot of data validation that I could do… but I do feel like it’s not my job to fix this database, so I’m probably not going to do that for the sake of a small side project. The part that is still missing is the terrestrial fiber links. There’s not good public data on those for a number of reasons, but you can be assured that there are significant backbone fiber optic cables buried nearby almost every major highway and rail line in the US. So imagine lines that nearly mimic the US road system, and you’ll have an idea of what that map would look like. That may actually be the next step for this map since it’s a bit hard to understand that we only have undersea cables. References: Github: https://github.com/sudorandom/submarine-cable-map PeeringDB: https://www.peeringdb.com/ Simple Maps (Geolocation Database): https://simplemaps.com/data/world-cities Submarine Cable Map: https://submarinecablemap.com Also published . here

Mapping the Internet: A Visualization of the Web

Having a suitable code editor is crucial during the coding process, as it plays a significant role in one's coding journey. Finding the right editor that suits your needs can greatly benefit your programming experience. Let’s create one ourselves now. Content Overview Introduction Setting up the application Creating the editor Steps Conclusion Introduction In this tutorial, we'll explore the process of building a functional web development (IDE) using within a Next.js application. Initially, we'll focus on creating an IDE that offers support for HTML, CSS, and JavaScript. Subsequently, we'll enhance the IDE by adding the capability to execute our code. Integrated Development Environment React Setting up the application To begin, let's generate a fresh Next.js project. We'll create the project within a directory named "web-editor" and make sure to enable and for it. JavaScript ESLint npx create-next-app contact-form --js --eslint This will create the folder and installs all the dependencies. The main file where we are going to be working is page.js inside src/app. Now enter the folder (cd contact-form) and start the development server: npm run dev Visit to check the running application. If everything is working, you should see a working web page. http://localhost:3000 Creating the Editor For building the editor in Next.js, we'll utilize monaco-react a library that enables us to integrate the monaco-editor seamlessly into our React application. The advantage of using this library is that we can avoid the complexities of configuring webpack, rollup, parcel, or similar tools that are typically required for incorporating the monaco-editor into our project. To start using this we first need to install it: npm install @monaco-editor/react After installing the Monaco-react package, you would have to go to the docs and then you'll see how to include it in your project. Copy and paste the below code in Page.js file: 'use client'

import Editor from '@monaco-editor/react';

export default function Home() {
  return (
    <Editor height="100vh" defaultLanguage="javascript" defaultValue="// some comment" />
  )
} You should see some like this. We now have an Integrated Development Environment (IDE) integrated into our web page. This IDE allows users to write and edit code directly on the webpage. By default, the editor is set to support JavaScript, but users have the flexibility to change the language according to their preference. Now, let's take some time to explore and understand the code implementation of this IDE. Numerous props are available for us to customize the editor according to our preferences. These props include options like and many others. By leveraging these props, we can easily make various changes and adjustments to the appearance and behavior of our editor to suit our specific needs and requirements. height, defaultLanguage, defaultValue, Theme, To ensure that our IDE supports HTML, CSS, and JavaScript, we need to add support for all three languages. For this purpose, we will use a prop called which enables us to manage the current file we are working on. This prop plays a crucial role in maintaining three distinct states, allowing us to seamlessly switch between the different files corresponding to HTML, CSS, and JavaScript code, making it possible to work on each of them effectively. path path I am also going to install as it will allow us to use different icons in our editor that we need. fontAwesome Copy and paste the below cmd: npm i --save @fortawesome/react-fontawesome@latest
npm i --save @fortawesome/free-brands-svg-icons@latest Copy and paste the below code in Page.js: 'use client'

import { useState } from 'react';
import Editor from '@monaco-editor/react';
import styles from './page.module.css';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'
import { faHtml5, faCss3, faJs } from '@fortawesome/free-brands-svg-icons'

const files = {
  'script.js': {
    name: 'script.js',
    language: 'javascript',
    value: "someJSCodeExample",
  },
  'style.css': {
    name: 'style.css',
    language: 'css',
    value: "someCSSCodeExample",
  },
  'index.html': {
    name: 'index.html',
    language: 'html',
    value: "someHTMLCodeExample",
  },
};

export default function Home() {
  const [fileName, setFileName] = useState('script.js');

  const file = files[fileName];

  return (
    <>
    <div className={styles.topBar}>
    <button className={styles.htmlButton} disabled={fileName === 'index.html'} onClick={() => setFileName('index.html')}>
      <div><FontAwesomeIcon icon={faHtml5} /></div>index.html
      </button>
      <button className={styles.cssButton} disabled={fileName === 'style.css'} onClick={() => setFileName('style.css')}>
      <div><FontAwesomeIcon icon={faCss3} /></div>style.css
      </button>
      <button className={styles.jsButton} disabled={fileName === 'script.js'} onClick={() => setFileName('script.js')}>
      <div><FontAwesomeIcon  icon={faJs} /></div> script.js
      </button>
    </div>
    <Editor
      height="100vh"
      theme="vs-dark"
      path={file.name}
      defaultLanguage={file.language}
      defaultValue={file.value}
    />
  </>
  )
} Our project should look something like this. The IDE doesn’t look the best as of now so let’s start working on that. I am also going to add a button to the code. Copy and paste the below code in page.js "use client";
import { useState } from "react";
import Editor from "@monaco-editor/react";
import styles from "./page.module.css";
import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
import { faHtml5, faCss3, faJs } from "@fortawesome/free-brands-svg-icons";
import { faPlay } from "@fortawesome/free-solid-svg-icons";

const files = {
  "index.html": {
    name: "index.html",
    language: "html",
    value: "",
  },
  "style.css": {
    name: "style.css",
    language: "css",
    value: "",
  },
  "script.js": {
    name: "script.js",
    language: "javascript",
    value: "",
  },
};

export default function Home() {
  const [fileName, setFileName] = useState("index.html");
  const file = files[fileName];

  return (
    <>
      <div>
        <div className={styles.topBar}>
          <button
            className={styles.htmlButton}
            disabled={fileName === "index.html"}
            onClick={() => setFileName("index.html")}
          >
            <div>
              <FontAwesomeIcon icon={faHtml5} />
            </div>
            index.html
          </button>
          <button
            className={styles.cssButton}
            disabled={fileName === "style.css"}
            onClick={() => setFileName("style.css")}
          >
            <div>
              <FontAwesomeIcon icon={faCss3} />
            </div>
            style.css
          </button>
          <button
            className={styles.jsButton}
            disabled={fileName === "script.js"}
            onClick={() => setFileName("script.js")}
          >
            <div>
              <FontAwesomeIcon icon={faJs} />
            </div>{" "}
            script.js
          </button>
          <button className={styles.playButton} id="runCode">
            <div>
              <FontAwesomeIcon icon={faPlay} />
            </div>{" "}
            Run
          </button>
        </div>
        <Editor
          height="100vh"
          theme="vs-dark"
          saveViewState={true}
          path={file.name}
          defaultLanguage={file.language}
          defaultValue={file.value}
        />
      </div>
    </>
  );
} This is all the CSS we will need in our project Copy and paste the below code in file. page.module.css .topBar{
  background-color: #242424;
  display: flex;

}

.jsButton,.cssButton, .htmlButton, .playButton, .closeButton {
  padding: 10px;
  font-size: 0.9rem;
  background-color: #242424;
  color: white;
  display: flex;
  flex-direction: row;
}

.closeButton{
  font-size: 1.2rem;
  box-shadow: 0 4px 10px 0 rgba(0,0,0,.2);
  font-weight: 700;
}

.htmlButton svg{
  color: rgb(248, 48, 48);
}

.cssButton svg{
  color: rgb(21, 130, 255);
}

.jsButton svg{
  color: rgb(243, 243, 16);
}

.playButton svg {
  color: rgb(46, 192, 46);
}

.closeButton svg {
  color: rgb(248, 48, 48);
}

.jsButton div,.htmlButton div, .cssButton div, .playButton div, .closeButton div {
  padding-right: 2px;
  margin: 1px;
}

.split{
  display: flex;
  flex-direction: row;
}


.editor {
  position: absolute;
}

.outputiframewindow {
  width: 50vw;
  height: 45vh;
  background-color: white;
}

.websiteWindow{
  position: absolute;
  z-index: 1;
  top: 30vh;
  left: 25vw;
}

.buttonBlock {
  background-color: #F0F4F4;
  box-shadow: 0 4px 10px 0 rgba(0,0,0,.2);
} This is how our IDE should look like now: We are now entering the exciting phase of the project where we focus on implementing the functionality to run the code within our IDE. To make it easier to understand, we will break down this process into several steps, ensuring a clear and systematic approach to this crucial part of our project. Let's dive into each step one by one and bring the code execution feature to life in our IDE. Steps The first step is to ensure that we can preserve the current state of the IDE, which involves saving the HTML, CSS, and JavaScript code entered by the user so that we can execute it later. To achieve this, we will utilize the hook, a powerful feature in React, which enables us to create and manage state variables. These state variables will store the code entered by the user, and we'll update them whenever the user runs the code. useState To keep track of the changes made in the IDE, we'll employ the event, which will allow us to detect any modifications made to the code and save those changes accordingly. onChange Now that we have the user's code stored, the next step is to figure out a way to execute it. For this purpose, we will leverage an , a popular HTML element that will facilitate code execution within a sandboxed environment, ensuring a safe and separate execution space for the code. iframe Copy and paste the below code in file. page.js "use client";
import { useState, useEffect, useRef } from "react";
import Editor from "@monaco-editor/react";
import styles from "./page.module.css";
import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
import { faHtml5, faCss3, faJs } from "@fortawesome/free-brands-svg-icons";
import { faPlay, faCircleXmark } from "@fortawesome/free-solid-svg-icons";

const files = {
  "index.html": {
    name: "index.html",
    language: "html",
    value: "",
  },
  "style.css": {
    name: "style.css",
    language: "css",
    value: "",
  },
  "script.js": {
    name: "script.js",
    language: "javascript",
    value: "",
  },
};

export default function Home() {
  const [fileName, setFileName] = useState("index.html");
  const [htmlCode, setHtmlCode] = useState("");
  const [cssCode, setCssCode] = useState("");
  const [jsCode, setJsCode] = useState("");

  function handleEditorChange(value) {
    file.value = value;
  }

  const file = files[fileName];

  useEffect(() => {
    const runBtn = document.getElementById("runCode");
    const clsBtn = document.getElementById("closeWindow");
    runBtn?.addEventListener("click", () => { 
      setHtmlCode(files["index.html"].value);
      setCssCode(files["style.css"].value);
      setJsCode(files["script.js"].value);
      document.getElementById("outputWindow").style.display = "block";
    });

    clsBtn?.addEventListener("click", () => {
      document.getElementById("outputWindow").style.display = "none";
    });
  }, []);

  return (
    <>
      <div>
        <div className={styles.topBar}>
          <button
            className={styles.htmlButton}
            disabled={fileName === "index.html"}
            onClick={() => setFileName("index.html")}
          >
            <div>
              <FontAwesomeIcon icon={faHtml5} />
            </div>
            index.html
          </button>
          <button
            className={styles.cssButton}
            disabled={fileName === "style.css"}
            onClick={() => setFileName("style.css")}
          >
            <div>
              <FontAwesomeIcon icon={faCss3} />
            </div>
            style.css
          </button>
          <button
            className={styles.jsButton}
            disabled={fileName === "script.js"}
            onClick={() => setFileName("script.js")}
          >
            <div>
              <FontAwesomeIcon icon={faJs} />
            </div>{" "}
            script.js
          </button>
          <button className={styles.playButton} id="runCode">
            <div>
              <FontAwesomeIcon icon={faPlay} />
            </div>{" "}
            Run
          </button>
        </div>
        <Editor
          height="100vh"
          theme="vs-dark"
          saveViewState={true}
          path={file.name}
          defaultLanguage={file.language}
          defaultValue={file.value}
          onChange={handleEditorChange}
          value={file.value}
        />
      </div>
      <div className={styles.websiteWindow} id="outputWindow">
        <div className={styles.buttonBlock}>
          <button className={styles.closeButton} id="closeWindow">
            <div>
              <FontAwesomeIcon icon={faCircleXmark} />
            </div>
          </button>
        </div>
        <iframe
          title="output"
          srcDoc={`
  <html>
    <body>${htmlCode}</body>
    <style>${cssCode}</style>
    <script>${jsCode}</script>
  </html>
`}
          className={styles.outputiframewindow}
        />
      </div>
    </>
  );
} This is how our final project looks. https://www.youtube.com/watch?v=_F27USYZ820&embedable=true Conclusion We have learned how to create a WebDev IDE on Next.js, we can see that we can run HTML, CSS and JavaScript in our IDE. Further possible improvements include adding better UI/UX, adding saving code feature, uploading files, creating different themes and a lot more. I also have a similar project with a lot of different features added you can check it out here . https://ide.lamtell.com/ You can check out the code here - code on github Also published here.

FORTA

fortahealth.com

-- employees

Since n.d.

COMPANY RANKING

FORTA

EVERGREEN INDEX #5183

Representing this company? Click here to claim and customize this page!

Forta WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

FORTA

fortahealth.com

-- employees

Since n.d.

COMPANY RANKING

FORTA

EVERGREEN INDEX #5183

RELATED COMPANIESRANK

STORIES ABOUT FORTA

Representing this company? Click here to claim and customize this page!

Forta WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!