Maitri Sharma

Maitri Sharma



The experimental value of radii and energies in hydrogen atoms are in good agreement with that calculated on the basis of Bohr’s theory.

Continue Reading:

#physics #science  #newton  #atom  #education 

Maitri Sharma

Maitri Sharma


Schottky and Frenkel Defects

Schottky defect is found when the atoms are missing from the crystal lattice.Frenkel defects are found when the atoms displaced their position into some voids or interstitial sites of the crystal lattice. Their are many differences between schottky and frenkel effects which are explained in this page in a detailed way



#biology #astronomy  #neet #space #physics  #astrophysics  #nasa  #universal  #math  #quantumphysics  #engineering  #atom  

Schottky and Frenkel Defects

A Julia Language Support Package for The Atom Editor

Julia Grammar

Julia grammar definition for Atom, VSCode, and GitHub.

The source of truth in this repo is grammars/julia.cson; julia.json and julia_vscode.json are automatically generated in a pre-commit hook.


Also an Atom package to provide Julia syntax highlighting, snippets, and docstring folding. Originally based off of JuliaLang/julia.tmBundle, merged with new ideas from language-julia.


  • Syntax highlighting
  • Snippets for common Julia keywords and constructs (see snippets/language-julia.cson)
  • Toggle folding of docstrings


Installation happens normally either through apm install language-julia or through the install section of the settings tab within Atom.

Note: if you already have a different version of language-julia plugin installed (e.g. this one), you would need to remove it first using apm uninstall language-julia

Recommended Extras

  • The LaTeX Completions package provides support for unicode characters similarly to the Julia REPL.
  • The Indent Detective package will help you keep to the style guidelines when working on Base or packages.
  • Install language-markdown for syntax highlighting in docstrings.
  • Install atom-language-r for syntax highlighting of R string macros.

Toggling docstrings

Two Atom commands are provided to toggle all docstrings or the docstring under the cursor: language-julia:toggle-docstrings and language-julia:toggle-all-docstrings. These are not assigned keys. Here is one example of adding these to keymaps using org-mode style keys:

'atom-text-editor[data-grammar="source julia"]:not([mini])':
  'tab':       'language-julia:toggle-docstrings'
  'shift-tab': 'language-julia:toggle-all-docstrings'


We love contributors. Here are the steps we have taken to develop on this package:

  1. Remove the official install of the package: apm uninstall language-julia
  2. Clone the repository somewhere we can remember: git clone
  3. Link the cloned package to ~/.atom (enter the following from the root of the repo directory): apm link .
  4. Hack away!

When new features are added, you should write specs to show that the package is behaving as expected. To run the specs you need to do the following:

  • Make sure you have the library's folder open in the current atom project.
  • Then open the command pallete and select Window: Run package specs. On OSX this key-binding is ctrl+cmd+option+p.

This should open up a new window with the spec results.

Contributor list

Download Details:

Author: JuliaEditorSupport
Source Code: 
License: View license

#julia #language #atom 

A Julia Language Support Package for The Atom Editor
Castore  DeRose

Castore DeRose


Cosmos Ecosystem Overview | Top 100 Project Built on Cosmos (ATOM)

In this article, you'll learn Cosmos, Cosmos Ecosystem Overview | Top 100 Project Built on Cosmos (ATOM)

1. What is Cosmos?


  • Cosmos makes blockchains powerful and easy to develop with Tendermint BFT and the modularity of the Cosmos SDK.
  • Cosmos enables blockchains to transfer value with each other through IBC and Peg-Zones, while letting them retain their sovereignty.
  • Cosmos allows blockchain applications to scale to millions of users through horizontal and vertical scalability solutions.

More than anything, Cosmos is not a product but an ecosystem built on a set of modular, adaptable and interchangeable tools. Developers are encouraged to join the effort to improve existing tools and create new ones in order to make the promise of blockchain technology a reality. These tools are the foundation needed to create the decentralized internet and global financial system of tomorrow.

How does Cosmos fit in the broader blockchain ecosystem?


To understand how Cosmos fits in the blockchain ecosystem, we need to go back to the beginning of the blockchain story. The first blockchain was Bitcoin, a peer-to-peer digital currency created in 2008 that used a novel consensus mechanism known as Proof-of-Work (PoW). It was the first decentralized application on a blockchain. Soon, people started to realize the potential of decentralized applications and the desire to build new ones emerged in the community.

At the time, there were two options to develop decentralized applications: either fork the bitcoin codebase or build on top of it. However, the bitcoin codebase was very monolithic; all three layers—networking, consensus and application — were mixed together. Additionally, the Bitcoin scripting language was limited and not user-friendly. There was a need for better tools.


In 2014, Ethereum came in with a new proposition for building decentralized applications. There would be a single blockchain where people would be able to deploy any kind of program. Ethereum achieved this by turning the Application layer into a virtual machine called the Ethereum Virtual Machine (EVM). This virtual machine was able to process programs called smart contracts that any developer could deploy to the Ethereum blockchain in a permissionless fashion. This new approach allowed thousands of developers to start building decentralized applications (dApps). However, limitations to this approach soon became apparent and still persist to this day.

Scalability: The first limitation is scaling - decentralized applications built on top of Ethereum are inhibited by a shared rate of 15 transactions per second. This is due to the fact that Ethereum still uses Proof-of-Work and that Ethereum dApps compete for the limited resources of a single blockchain.

Usability: The second limitation is the relatively low flexibility granted to developers. Because the EVM is a sandbox that needs to accommodate all use cases, it optimizes for the average use case. This means that developers have to make compromises on the design and efficiency of their application (for example, requiring use of the account model in a payments platform where a UTXO model may be preferred). Among other things, they are limited to a few programming languages and cannot implement automatic execution of code.

Sovereignty: The third limitation is that each application is limited in sovereignty, because they all share the same underlying environment. Essentially, this creates two layers of governance: that of the application, and that of the underlying environment. The former is limited by the latter. If there is a bug in the application, nothing can be done about it without the approval of the governance of the Ethereum platform itself. If the application requires a new feature in the EVM, it again has to rely entirely on the governance of the Ethereum platform to accept it.

These limitations are not specific to Ethereum but to all blockchains trying to create a single platform that would fit all use cases. This is where Cosmos comes into play.


The vision of Cosmos is to make it easy for developers to build blockchains and break the barriers between blockchains by allowing them to transact with each other. The end goal is to create an Internet of Blockchains, a network of blockchains able to communicate with each other in a decentralized way. With Cosmos, blockchains can maintain sovereignty, process transactions quickly and communicate with other blockchains in the ecosystem, making it optimal for a variety of use cases.

This vision is achieved through a set of open source tools like Tendermint, the Cosmos SDK and IBC designed to let people build custom, secure, scalable and interoperable blockchain applications quickly. Let us take a closer look at some of the most important tools in the ecosystem as well as the technical architecture of the Cosmos network. Note that Cosmos is an open source community project initially built by the Tendermint team. Everyone is welcome to build additional tools to enrich the greater developer ecosystem.

What is Tendermint BFT and the ABCI

Until recently, building a blockchain required building all three layers (Networking, Consensus, and Application) from the ground up. Ethereum simplified the development of decentralized applications by providing a Virtual-Machine blockchain on which anyone could deploy custom logic in the form of Smart Contracts. However, it did not simplify the development of blockchains themselves. Much like Bitcoin, Go-Ethereum remains a monolithic tech stack that is difficult to fork from and customize. This is where Tendermint, created by Jae Kwon in 2014, came in.

Tendermint BFT is a solution that packages the networking and consensus layers of a blockchain into a generic engine, allowing developers to focus on application development as opposed to the complex underlying protocol. As a result, Tendermint saves hundreds of hours of development time. Note that Tendermint also designates the name of the byzantine fault tolerant (BFT) consensus algorithm used within the Tendermint BFT engine. For more on the history of consensus protocols and BFT you can check this cool podcast by Tendermint co-founder Ethan Buchman.

The Tendermint BFT engine is connected to the application by a socket protocol called the Application Blockchain Interface (ABCI). This protocol can be wrapped in any programming language, making it possible for developers to choose a language that fits their needs.

But that is not all. Here are the properties that make Tendermint BFT a state-of-the-art blockchain engine:

  • Public or private blockchain ready: Tendermint BFT only handles networking and consensus for a blockchain, meaning that it helps nodes propagate transactions and validators agree on a set of transactions to append to the blockchain. It is the role of the application layer to define how the validator set
  • is constituted. Developers can therefore build both public and private blockchains on top of the Tendermint BFT engine. If the application defines that validators are elected based on how many tokens they have at stake, then the blockchain can be characterised as Proof-of-Stake (PoS)
  • . If however the application defines that only a restricted set of pre-authorized entities can be validators, then the blockchain can be characterised as permissioned or private. Developers have all the freedom to customize the rules that define how the validator set of their blockchain changes.
  • High Performance: Tendermint BFT can have a block time on the order of 1 second and handle up to thousands of transactions per second.
  • Instant finality: A property of the Tendermint consensus algorithm is instant finality. This means that forks are never created as long as more than a third of the validators are honest (byzantine). Users can be sure their transactions are finalized as soon as a block is created (which is not the case in Proof-of-Work blockchains like Bitcoin and Ethereum).
  • Security: Tendermint consensus is not only fault tolerant, it is also accountable. If the blockchain forks, there is a way to determine liability.

Cosmos SDK and other application layer frameworks

Tendermint BFT reduces the development time of a blockchain from years to weeks, but building a secure ABCI-app from scratch remains a difficult task. This is why the Cosmos SDK exists.

The Cosmos SDK is a generalized framework that simplifies the process of building secure blockchain applications on top of Tendermint BFT. It is based on two major principles:

  • Modularity: The goal of the Cosmos SDK is to create an ecosystem of modules
  • that allows developers to easily spin up application-specific blockchains
  • without having to code each bit of functionality of their application from scratch. Anyone can create a module for the Cosmos SDK, and using ready built modules in your blockchain is as simple as importing them into your application. For example, the Tendermint team is building a set of basic modules that are needed for the Cosmos Hub
  • . These modules can be used by any developer as they build their own application. Additionally, developers can create new modules to customize their application. As the Cosmos network develops, the ecosystem of SDK modules will expand, making it increasingly easier to develop complex blockchain applications.
  • Capabilities-based security: Capabilities constrain the security boundaries between modules, enabling developers to better reason about the composability of modules and limit the scope of malicious or unexpected interactions.

The Cosmos SDK also comes with a set of useful developer tools for building command line interfaces (CLI), REST servers and a variety of other commonly used utility libraries.

One final remark: the Cosmos SDK, like all Cosmos tools, is designed to be modular. Today, it allows developers to build on top of Tendermint BFT. However, it can be used with any other consensus engines that implements the ABCI. As time goes by, we expect multiple SDKs to emerge, built with different architecture models and compatible with multiple consensus engines - all within a single ecosystem: the Cosmos Network.


The great thing about the Cosmos SDK is that its modularity allows developers to port virtually any existing blockchain codebase already in Golang on top of it. For example, Ethermint

is a project that ports the Ethereum Virtual Machine into an SDK module. Ethermint works exactly like Ethereum but also benefits from all the properties of Tendermint BFT. All the existing Ethereum tools (Truffle, Metamask, etc.) are compatible with Ethermint and you can port your smart contracts over without additional work.

Today are developed on top of Virtual Machine blockchains like Ethereum. First, it should be stated that the reason for this phenomenon is that up until now blockchains were much more difficult to develop than Smart Contracts. This is not the case anymore, thanks to the Cosmos SDK. Now, developers can easily develop entire application-specific blockchains, which have several advantages. Among others, they give more flexibility, security, performance and sovereignty. Of course, if you don’t want to build your own blockchain, you can still make your Smart Contracts compatible with Cosmos by deploying them on Ethermint.

Connecting Blockchains Together - IBC

Now that developers have a way to quickly build customized blockchains, let us see how to connect these blockchains together. The connection between blockchains is achieved through a protocol called Inter-Blockchain Communication protocol (IBC). IBC leverages the instant finality property of Tendermint consensus (although it can work with any “fast-finality” blockchain engine) to allow heterogeneous chains to transfer value (i.e. tokens) or data to each other.


Essentially it comes down to two things:

  • Different layers: Heterogeneous chains have different layers, meaning they can differ in how they implement the networking, consensus and application parts. To be compatible with IBC, a blockchain needs only follow a few requirements, the main one being that the consensus layer must have fast finality. Proof-of-Work chains (like Bitcoin and Ethereum) do not fall in this category, as they have probabilistic finality.
  • Sovereignty: Every blockchain is maintained by a set of validators whose job is to agree on the next block to commit to the blockchain. In Proof-of-Work blockchains these validators are called miners. A sovereign blockchain is a blockchain with its own validator set. In many instances it is important for blockchains to be sovereign, as validators are ultimately responsible for modifying the state. In Ethereum, applications are all run by a common set of validators. Because of this, each application only has limited sovereignty.

IBC allows heterogeneous blockchains to transfer tokens and data to each other, meaning that blockchains with different applications and validator sets are interoperable. For example, it allows public and private blockchains to transfer tokens to each other. Currently, no other blockchain framework enables this level of interoperability.


The principle behind IBC is fairly simple. Let us take an example where an account on chain A wants to send 10 tokens (let us call them ATOM) to chain B.

  • Tracking: Continuously, chain B receives the headers of chain A, and vice versa. This allows each chain to track the validator set of the other. In essence, each chain runs a light-client of the other.
  • Bonding: When the IBC transfer is initiated, the ATOM are locked up (bonded) on chain A.
  • Proof Relay: Then, a proof that the 10 ATOM are bonded is relayed from chain A to chain B.
  • Validation: The proof is verified on chain B against chain A’s header and, if it is valid, then 10 ATOM-vouchers are created on chain B.

How IBC Works #4

Note that the ATOM that have been created on chain B are not real ATOM, as ATOM only exist on chain A. They are a representation on B of ATOM from chain A, along with a proof that these ATOM are frozen on chain A. A similar mechanism is used to unlock ATOM when they come back to their origin chain. 

Designing the “Internet of Blockchains”

IBC is a protocol that allows two heterogeneous blockchains to transfer tokens to each other. From there, how do we create a network of blockchains?

One idea is to connect each blockchain in the network with every other via direct IBC connections. The main problem with this approach is that the number of connections in the network grows quadratically with the number of blockchains. If there are 100 blockchains in the network and each needs to maintain an IBC connection with every other, that is 4950 connections. This quickly gets out of hand.

To solve this, Cosmos proposes a modular architecture with two classes of blockchain: Hubs and Zones. Zones are regular heterogenous blockchains and Hubs are blockchains specifically designed to connect Zones together. When a Zone creates an IBC connection with a Hub, it can automatically access (i.e. send to and receive from) every other Zone that is connected to it. As a result, each Zone only needs to establish a limited number of connections with a restricted set of Hubs. Hubs also prevent double spending among Zones. This means that when a Zone receives a token from a Hub, it only needs to trust the origin Zone of this token and the Hub.

The first Hub launched in the Cosmos Network is the Cosmos Hub. The Cosmos Hub is a public Proof-of-Stake blockchain whose native staking token is called the ATOM, and where transactions fees will be payable in multiple tokens. The launch of the Hub also marks the launch of the Cosmos network.

Bridging non-Tendermint chains

So far, the architecture of Cosmos we have presented shows how Tendermint-based chains can interoperate. But Cosmos is not limited to Tendermint chains. In fact, any kind of blockchain can be connected to Cosmos.

We have two cases to distinguish: fast-finality chains and probabilistic-finality chains.


Blockchains that use any fast-finality consensus algorithms can connect with Cosmos by adapting IBC. For example, if Ethereum were to switch to Casper FFG (Friendly Finality Gadget), a direct connection could be established between it and the Cosmos Ecosystem by adapting IBC to work with Casper.


For blockchains that do not have fast-finality, like Proof-of-Work chains, things get a bit trickier. For these chains we use a special kind of proxy-chain called a Peg-Zone. A Peg-Zone is a blockchain that tracks the state of another blockchain. The Peg-Zone itself has fast-finality and is therefore compatible with IBC. Its role is to establish finality for the blockchain it bridges. Let us look at the following example.

Example: Ethereum Peg-Zone

Interestingly enough, the Peg-Zone also allows users to send any token that lives on Cosmos to the Ethereum chain (the Cosmos tokens would be represented as ERC20 on the Ethereum chain). The Tendermint team is currently working on a Peg-Zone implementation for the Ethereum chain called Peggy.

Peg-Zones will need to be customized for the particular chain they bridge. Building an Ethereum Peg-Zone is relatively simple because Ethereum is account-based and has smart-contracts. However, building a Bitcoin Peg-Zone is a bit more challenging. Explaining how to build a Bitcoin-like Peg-Zone is out-of-scope for this intro but know that it is theoretically possible. If you want to learn more about Peg-Zones you can take a look at this spec.

Solving Scalability

Now that we can easily create and connect blockchains there is one final issue to tackle: Scalability. Cosmos leverages two types of scalability:

  • Vertical scalability: This encompasses the methods for scaling the blockchain itself. By moving away from Proof-of-Work and optimizing its components, Tendermint BFT can reach thousands of transactions per-second. The bottleneck factor is the application itself. For example, an application like a Virtual Machine (e.g. the Ethereum Virtual Machine) will impose a much lower limit on the transaction throughput than an application where transaction types and state transition
  • functions are directly embedded in it (e.g. a standard Cosmos SDK application). This is one of the reasons why application-specific blockchains make sense.
  • Horizontal scalability: Even if the consensus engine and the application are highly optimized, at some point the transaction throughput of a single chain inevitably hits a wall it cannot surpass. That is the limit of vertical scaling. To go beyond it, the solution is to move to multi-chain architectures. The idea is to have multiple parallel chains running the same application and operated by a common validator set, making blockchains theoretically infinitely scalable. Details about horizontal scalability are fairly complex and out-of-scope for this intro.

Cosmos will offer very good vertical scalability at launch, which will be a major improvement over current blockchain solutions in and of itself. Later, after the completion of the IBC module, horizontal scalability solutions will be implemented.

Top exchanges for ATOM trading.

2. Cosmos Ecosystem Overview

The Cosmos ecosystem is a decentralized network designed to connect various blockchains as part of an ambitious drive to power an ‘Internet of blockchains’. Using a novel technology called Inter-Blockchain Communication (IBC) protocol, Cosmos is able to facilitate seamless interaction and exchange of information between chains in its ecosystem. At the same time, Cosmos also offers tools that can drastically streamline and speed up the development of purpose-built blockchains, as part of a bid to reimagine what building blockchain applications can really be. 

Ultimately, Cosmos seeks to solve the limitations of the current generation of blockchain tech and usher in a new era of increased scalability, usability and interoperability in the blockchain space. 

Behind CosmosCosmos NetworkCosmos is an ever-expanding ecosystem of interconnected apps and services, built for a decentralized future.ATOM BinanceWebsite
Cosmos SDKThe worlds most popular blockchain framework. Over $6 billion in assets are managed by public blockchains built with the Cosmos SDK. Build yours today.ATOM BinanceWebsite
TendermintBuilding the most powerful tools for distributed networks.  Website
IBC ProtocollIBC is an interoperability protocol for communicating arbitrary data between arbitrary state machines. It provides an end-to-end, connection-oriented, stateful protocol for reliable, ordered, and authenticated communication between heterogeneous blockchains or off-chain protocols (rollups), and can accomodate for both known and dynamic validator topologies.  Website
DEX AMM SwapsThorchainDECENTRALIZED LIQUIDITY PROTOCOL Deposit native assets into Liquidity Pools to earn yield. The network is 100% autonomous and decentralized.RUNEBinanceWebsite
Injective ProtocolInjective enables access to unlimited decentralized finance markets. Users can create any financial market on Injective’s fast, cross-chain, zero gas fee, secure, and fully decentralized exchange protocol.INJBinanceWebsite
OsmosisOsmosis DEX for the Cosmos ecosystem.OSMOMEXCWebsite
VegaVega has designed fully automated processes for creating markets on and trading margined derivatives. Markets will be open and decentralised, with pseudonymous participants.VEGA Website
Gravity BridgeEnter the portal to cross-chain DeFi. Swap, transfer, and pool assets with Emeris. Manage assets across multiple chains all in one place, elevating your DeFi experience to the next level.  Website
Sommelier FinanceSommelier is a coprocessor for Ethereum that moves DeFi assets from Automated Money Markets into higher yields more quickly and cheaply than was previously possible through non automated yield farming across different protocols.SOMM Website
Bridges Cross Chain InteroperabilityIrisnetIRISnet (a.k.a IRIS Hub) is designed to be the foundation for the next generation distributed applications. Built with Cosmos-SDK, IRIS Hub enables cross-chain interoperability through a unified service model, while providing a variety of modules to support DeFi applications. 

IRIS Hub is designed to support not only token transfers across internet of blockchains, but also to allow consumption of data and computing resources across heterogenous systems mechanism, token economics, etc.)
Loomx NetworkLoom Network provides developers the scalability and usability they need to build high-performance user-facing dapps today. With seamless integrations to Bitcoin, Ethereum, Binance Chain, and all major blockchains, deploying once to Loom lets you future-proof your dapp by reaching the largest number of users possible.LOOMBinanceWebsite
UmeeUmee is a layer-one blockchain built on Cosmos designed to create a universal cross-chain DeFi hub. It serves as a base layer for future DApps and money legos. Thanks to the interoperability of the Tendermint Proof-of-stake consensus mechanism used, the Umee blockchain can be integrated with Cosmos, Ethereum, side chains, layer-two chains, and alternative base-layer protocols.UMEEFTXWebsite
InterchainWe believe that open-source, cryptographic, consensus-driven, economic networks hold the key to an anti-fragile global economic system and equal opportunity for all. Our current focus is on the interoperable blockchain technology of the Cosmos Network  Website
AxelarAxelar is an overlay network, delivering Turing-complete message passing via proof-of-stake and permissionless protocols. Developers use Axelar to go beyond bridges, creating dApps that securely integrate users, functions and assets across all of the decentralized web.AXL Website
Liquid StakingPersistencePersistence is enabling exposure to multiple asset classes such as Liquid Staking (pSTAKE), NFTs (Asset Mantle) and Synthetics (Comdex). Persistence’s mission is to create an ecosystem of multi-chain Web3 products designed to stimulate global liquidity and enable seamless value exchange.

Persistence’s Core mainnet is a Proof-of-Stake chain powered by Tendermint BFT consensus engine. Persistence’s multi-chain tech stack (currently supporting Cosmos, Ethereum and other Tendermint-based chains) abstracts away the complexities for developers and enables them to create DEXs, marketplaces, lending/borrowing platforms etc.
Lido FinanceLido is a liquid staking protocol for POS blockchains. It gives you a liquid token that represents your staked collateral and earnings over time. Lido removes the need to run infrastructure and enabling continued participation in DeFi.

wstETH is a wrapped version of stETH. Instead of rebasing, or changing account holdings daily it is similar to a c-token. It represents a pro-rata ownership of the staked ETH (stETH). When someone exits wstETH they are returned principal stETH + stETH earnings.
Smart Contract EVMKadenaKadena is a proof-of-work blockchain that combines the PoW consensus mechanism from Bitcoin with directed acyclic graph (DAG) principles to offer a scalable version of Bitcoin. Kadena claims it can provide the security of Bitcoin while being able to offer unparalleled throughput that makes the blockchain usable to enterprises and entrepreneurs alike. Kadena's unique infrastructure is decentralized and built for mass adoption because of its multi-chain approach.KDABinanceWebsite
JunoJuno is a sovereign public blockchain in the Cosmos ecosystem, which provides an environment for the deployment of interoperable smart contracts. The network serves as a decentralized, permissionless & censorship resistant avenue for developers to efficiently and securely launch smart contracts using proven frameworks and compile them in various languages Rust & Go. Battle tested contract modules such as CosmWasm, allow for decentralized applications (dapps) to be compiled on robust and secure multi-chain smart contracts.
EvmosEvmos is an Inter-Blockchain Communication protocol, a.k.a. IBC; the IP layer for blockchains. IBC is currently the safest and most secure and decentralized way to move assets across different blockchains, unlocking interoperability across multiple chains.

Evmos leverages the Cosmos SDK serves as the first IBC-compatible EVM-based chain, bringing composability, interoperability, and fast finality to Ethereum.
CronosCronos Chain. Get Instant DApp Portability with EVM Support.  Website
CosmwasmBuild your robust dApps on secure, multi-chain smart contracts!  Website
AgoricBuild Fast, Earn FastTM. A Proof-of-Stake chain utilizing secure JavaScript smart contracts to rapidly build and deploy DeFi.BLD Website
PrivacySecret NetworkSecret Network is the first blockchain with data privacy by default, allowing you to build and use applications that are both permissionless and privacy-preserving. This unique functionality protects users, secures applications, and unlocks hundreds of new use cases for Web 3.SCRTBinanceWebsite
Oasis ProtocolA new era of blockchain. The Oasis Network is a privacy-enabled blockchain platform for open finance and a responsible data economy.ROSEBinanceWebsite
Nym TechExisting internet protocols leak sensitive data that can be used without users knowledge — Nym is developing the infrastructure to prevent this data leakage by protecting every packet’s metadata at the network and application layers.NYMOKXWebsite
Anoma NetworkUndefining Money. A sovereign, proof-of-stake blockchain protocol that enables private, asset-agnostic cash and private bartering among any number of parties.  Website
IdentityStarnameIt enables users to receive crypto-currencies or to log in to blockchain applications in a seamless way. Transferring value becomes fast and easy.IOVHotbitWebsite
WetrustBuild, share, and manage your digital identity. Securely build your online profile and reputation.TRSTBancorWebsite
CheqdBuilding a private and secure SSI digital credentials network on Cosmos for the trusted data economy.CHEQGateWebsite
AI and CloudAkashDEPLOY FASTER. SCALE QUICKLY. Censorship-resistant, permissionless, and self-sovereign, Akash Network is the world’s first open source cloud.AKTGateWebsite
VitwitBuild. Automate. Scale. We build Intelligent & autonomous solutions for our clients as part of digital transformations in the AI era. We pioneer the technology to empower businesses with insights and intelligent systems.  Website
SustainabilityRegen NetworkRegen Ledger is a sovereign, proof-of-stake blockchain built on the Cosmos SDK. REGEN is a staking token, providing Regen Ledger with utility - namely, fees, gas, governance and security.REGENOsmosisWebsite
IXOThe ixo protocol defines a new open standard for producing verifiable claims about changes in the state of the world.
Lend and BorrowKavaKava is a Layer-1 blockchain that combines the speed and interoperability of Cosmos with the developer power of Ethereum.

The Kava Network uses a developer-optimized co-chain architecture. The Ethereum Co-Chain enables support for EVM smart contracts while the Cosmos Co-Chain enables the lightning-fast Tendermint consensus engine and the Inter Blockchain Communication Protocol (IBC).
Social MediaDesmos NetworkA blockchain which serves as the backbone to empower the development of user-centric social networks.DSMOsmosisWebsite
Data OraclesMicrotickDatapace is Blockchain powered data marketplace with technical and policy-based data verification, and access to the worldwide network of sensors.TICKOsmosisWebsite
FoamFOAM's mission is to build a consensus driven map of the world, empowering a fully decentralized web3 economy with verifiable location data. FOAM incentivizes the infrastructure needed for privacy-preserving and fraud-proof location verification. The starting point for FOAM is the FOAM Map, where a community of Cartographers curate geographic Points of Interest on the FOAM map. FOAMPoloniexWebsite
VPNSentinelSentinel (DVPN) is a cryptocurrency and operates on the Cosmos platform.DVPNMEXCWebsite
PaymentBitcannaBitCanna aims to become the global digital ancillary platform for the cannabis industry. The focus for the team lies on building an application that will serve both businesses as consumers from within the industry. Blockchain is the means as an infrastructure to build this application on top.
DappCrypto com CROBinanceWebsite
CeFi & DeFiComdexComdex is a DeFi infrastructure layer for the Cosmos ecosystem. Comdex provides a variety of interoperable plug & play modules for projects to use to create their own DeFi platforms providing utility to the Cosmos community as well as DeFi users worldwide.CMDXOsmosisWebsite
Kira NetworkKIRA is a Layer 1 network enabling market access to any digital asset in the cryptocurrency ecosystem. Users can earn block and fee rewards from staking any digital asset on multiple chains at the same time, while maintaining full liquidity and custody over their funds, whether trading on KIRA or using other DeFi apps simultaneously.
KI ChainBridging CeFi with DeFi Block by Block.  Website
NFTBitsongBitSong is a distributed (open source) blockchain music ecosystem born in December 2017, to create a decentralized and trustless hub that interconnects the various market players.

Artists, Fans, Managers and Labels in One Single Holistic Ecosystem: $BTSG. Earn real-time royalties, discover exclusive content, mint and trade fan tokens, buy & sell NFTs.
StargazeStargaze is a decentralized and community-owned network for NFTs. It is built as an app-specific Cosmos Proof-of_stake chain, running the Tendermint consensus engine. It’s goal is to be similar to OpenSea, except governed by a community via a curation DAO and a protocol DAO.

Stargaze will allow users to buy, sell, and trade NFTs. It will also allow trading NFTs across other IBC-enabled chains. It will also interoperate with Ethereum over Gravity Bridge.
OmniflixDecentralized media and network layer for Creators & Sovereign Communities powered by NFTs and related distribution protocols.  Website
Pylons techWe believe that distributed consensus will power new forms of individual and corporate expression — leading to enhanced community interactions. Built on Cosmos, Pylons is a fast and interoperable system for brands and creators to build engaging products with meaningful NFT experiences.  Website
Web 3LikeCoinLikeCoin (LIKE) is the native token of the LikeCoin chain built from the Cosmos SDK. LikeCoin is a inter-chain protocol and framework for decentralized publishing. It is an application-specific blockchain for building and bridging media to Web 3. LIKEOsmosisWebsite
BostromDecentralized web 3.0 search engineBOOTOsmosisWebsite
BluzelleBluzelle delivers high security, un-matched availability, and is censorship resistant. Whether you are an artist, musician, scientist, publisher, or developer, Bluzelle protects the intellectual property of all creators. Bluzelle is data storage, file storage, oracles, and more. Its is specific for NFTs and DeFi.BLZBinanceWebsite
Cosmos WalletKeplrKeplr Wallet for the Cosmos Ecosystem  Website
CosmostationCosmos Wallet and Enterprise-level Proof-of-Stake validator node operation & end-user applications.  Website


  • The Cosmos ecosystem experienced strong growth in 2021. The application-specific blockchain architecture is gaining popularity within the industry. While these trends are very encouraging, from an investment standpoint, it is not clear exactly who value will accrue to within the ecosystem.
  • Although there are now a plethora of EVM blockchains, EVMos is uniquely positioned to integrate the Ethereum and Cosmos ecosystems. It will be interesting to see how the dApp store model in EVMos’ tokenomics manifests into developer activity.
  • The recent Wormhole (a bridge between Ethereum and Solana) smart contract hack has raised a lot of questions as to the viability of cross-chain integration. EVMos has partnered with Nomad and Connext to bridge assets between Ethereum and Cosmos. Security of these bridges will be paramount for successful integration.
  • The CEVMos modular architecture breaks the blockchain into its three core functions, specializing for each. While still in development (Celestia has not yet launched testnet), the partnership is extremely promising, and could establish a new industry paradigm.

I hope this article will help you. Don't forget to leave a like, comment and sharing it with others. Thank you!

Read more: Ethereum Ecosystem Overview | Top 200 Project Built on Ethereum (ETH)

#blockchain #bitcoin #cryptocurrency #cosmos #atom 

Cosmos Ecosystem Overview | Top 100 Project Built on Cosmos (ATOM)
Royce  Reinger

Royce Reinger


Simple-rss: A Simple, Flexible, Extensible, Liberal RSS & Atom Reader

Welcome to Simple RSS

Simple RSS is a simple, flexible, extensible, and liberal RSS and Atom reader for Ruby. It is designed to be backwards compatible with the standard RSS parser, but will never do RSS generation.


The API is similar to Ruby's standard RSS parser:

require 'rubygems'
require 'simple-rss'
require 'open-uri'

rss = SimpleRSS.parse open('') # => "Slashdot" # => "" # => ""

But since the parser can read Atom feeds as easily as RSS feeds, there are optional aliases that allow more atom like reading:

rss.feed.title # => "Slashdot" # => "" # => ""

The parser does not care about the correctness of the XML as it does not use an XML library to read the information. Thus it is flexible and allows for easy extending via:

SimpleRSS.feed_tags << :some_new_tag
SimpleRSS.item_tags << :"item+myrel" # this will extend SimpleRSS to be able to parse RSS items or ATOM entries that have a rel specified, common in many blogger feeds
SimpleRSS.item_tags << :"feedburner:origLink" # this will extend SimpleRSS to be able to parse RSS items or ATOM entries that have a specific pre-tag specified, common in many feedburner feeds
SimpleRSS.item_tags << :"media:content#url" # this will grab the url attribute of the media:content tag 


Author: cardmagic
Source Code: 
License: View license

#ruby #atom 

Simple-rss: A Simple, Flexible, Extensible, Liberal RSS & Atom Reader
Royce  Reinger

Royce Reinger


Ratom: A Fast, Libxml Based, Ruby Atom Library


rAtom is a library for working with the Atom Syndication Format and the Atom Publishing Protocol (APP).

Built using libxml so it is much faster than a REXML based library.

Uses the libxml pull parser so it has much lighter memory usage.

Supports RFC 5005 for feed pagination.

rAtom was originally built to support the communication between a number of applications built by Peerworks, via the Atom Publishing protocol. However, it supports, or aims to support, all the Atom Syndication Format and Publication Protocol and can be used to access Atom feeds or to script publishing entries to a blog supporting APP.

Build Status

API docs are here.


libxml-ruby, >= 1.1.2

rspec (Only required for tests)

libxml-ruby in turn requires the libxml2 library to be installed. libxml2 can be downloaded from or installed using whatever tools are provided by your platform. At least version 2.6.31 is required.


Mac OSX by default comes with an old version of libxml2 that will not work with rAtom. You will need to install a more recent version. If you are using Macports:

port install libxml2

Alternatively, using Homebrew:

brew install libxml2


You can install via gem using:

gem install ratom


To fetch a parse an Atom Feed you can simply:

require 'atom'

feed = Atom::Feed.load_feed(URI.parse(""))

And then iterate over the entries in the feed using:

feed.each_entry do |entry|
  # do cool stuff

To construct the following example Feed is from the Atom spec:

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="">

  <title>Example Feed</title> 
  <link href=""/>
    <name>John Doe</name>

    <title>Atom-Powered Robots Run Amok</title>
    <link href=""/>
    <summary>Some text.</summary>


To build this in rAtom we would do:

feed = do |f|
  f.title = "Example Feed"
  f.links << => "")
  f.updated = Time.parse('2003-12-13T18:30:02Z')
  f.authors << => 'John Doe') = "urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6"
  f.entries << do |e|
    e.title = "Atom-Powered Robots Run Amok"
    e.links << => "") = "urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a"
    e.updated = Time.parse('2003-12-13T18:30:02Z')
    e.summary = "Some text."

To output the Feed as XML use to_xml

> puts feed.to_xml
<?xml version="1.0"?>
<feed xmlns="">
  <title>Example Feed</title>
  <link href=""/>
    <name>John Doe</name>
    <title>Atom-Powered Robots Run Amok</title>
    <summary>Some text.</summary>
    <link href=""/>

See Feed and Entry for details on the methods and attributes of those classes.


To publish to a remote feed using the Atom Publishing Protocol, first you need to create a collection to publish to:

require 'atom/pub'

collection = => '')

Then create a new entry

entry = do |entry|
  entry.title = "I have discovered rAtom"
  entry.authors << => 'A happy developer')
  entry.updated = = ""
  entry.content ="<p>rAtom lets me post to my blog using Ruby, how cool!</p>")

And publish it to the Collection:

published_entry = collection.publish(entry)

Publish returns an updated entry filled out with any attributes to server may have set, including information required to let us update to the entry. For example, lets change the content and republished:

published_entry.content ="<p>rAtom lets me post to and edit my blog using Ruby, how cool!</p>")
published_entry.updated =!

To update an existing Entry:

existing_entry = Entry.load_entry(URI.parse(""))

existing_entry.title = "I have discovered rAtom"
existing_entry.updated =!

You can also delete an entry using the destroy! method, but we won't do that will we?.

Extension elements

As of version 0.3.0, rAtom support simple extension elements on feeds and entries. As defined in the Atom Syndication Format, simple extension elements consist of XML elements from a non-Atom namespace that have no attributes or child elements, i.e. they are empty or only contain text content. These elements are treated as a name value pair where the element namespace and local name make up the key and the content of the element is the value, empty elements will be treated as an empty string.

To access extension elements use the [] method on the Feed or Entry. For example, if we are parsing the follow Atom document with extensions:

<?xml version="1.0"?>
<feed xmlns="" xmlns:ex="">
  <title>Feed with extensions</title>
  <ex:myelement>Something important</ex:myelement>

We could then access the extension element on the feed using:

> feed["", "myelement"]
=> ["Something important"]

Note that the return value is an array. This is because XML allows multiple instances of the element.

To set an extension element you append to the array:

> feed['', 'myelement'] << 'Something less important'
=> ["Something important", "Something less important"]

You can then call to_xml and rAtom will serialize the extension elements into xml.

> puts feed.to_xml
<?xml version="1.0"?>
<feed xmlns="">
  <myelement xmlns="">Something important</myelement>
  <myelement xmlns="">Something less important</myelement>

Notice that the output repeats the xmlns attribute for each of the extensions, this is semantically the same the input XML, just a bit ugly. It seems to be a limitation of the libxml-Ruby API. But if anyone knows a work around I'd gladly accept a patch (or even advice).

Custom Extension Classes 

As of version 0.5.0 you can also define your own classes for a extension elements. This is done by first creating an alias for the namespace for the class and then using the element method on the Atom::Feed or Atom::Entry class to tell rAtom to use your custom class when it encounters the extension element.

For example, say we have the following piece Atom XML with a structured extension element:

<?xml version='1.0' encoding='UTF-8'?>
<entry xmlns='' xmlns:custom='http://custom.namespace'>
  <link rel='self' type='application/atom+xml' href='https://custom.namespace/id/1'/>
  <custom:property name='foo' value='bar'/>
  <custom:property name='baz' value='bat'/>

And we want the custom:property elements to be parsed as our own custom class called Custom::Property that is defined like this:

class Custom::Property
  attr_accessor :name, :value
  def initialize(xml)
    # Custom XML handling

We can tell rAtom about our custom namespace and custom class using the following method calls:

Atom::Entry.add_extension_namespace :custom, "http://custom.namespace"
Atom::Entry.elements "custom:property", :class => Custom::Property

The first method call registers an alias for the “custom.namespace” namespace and the second method call tell rAtom that when it encounters a custom:property element within a Feed it should create an instance of Custom::Property and pass the XML Reader to the constructor of the instance. It is then up to the constructor to populate the objects attributes from the XML. Note that the alias you create using add_extension_namespace can be anything you want, it doesn't need to match the alias in the actual XML itself.

The custom property will then be available as a method on the rAtom class. In the above example:

@feed.custom_property.size == 2 == 'foo'
@feed.custom_property.first.value == 'bar'

There is one caveat to this. By using this type of extension support you are permanently modifying the rAtom classes. So if your application process one type of atom extension and you are happy with permanently modified rAtom classes, the extra extensibility might work for you. If on the other hand you process lots of different types of extension you might want to stick with simpler extension mechanism using the [namespace, element] method described above.

(Thanks to nachokb for this feature!!)

Basic Authentication

All methods that involve HTTP requests now support HTTP Basic Authentication. Authentication credentials are passed as :user and :pass parameters to the methods that invoke the request. For example you can load a feed with HTTP Basic Authentication using:

Atom::Feed.load_entry(URI.parse(""), :user => 'username', :pass => 'password')

Likewise all the Atom Pub methods support similar parameters, for example you can publish an Entry to a Feed with authentication using:

feed.publish(entry, :user => 'username', :pass => 'password')

Or destroy an entry with:

entry.destroy!(:user => 'username', :pass => 'password')

rAtom doesn't store these credentials anywhere within the object model so you will need to pass them as arguments to every method call that requires them. This might be a bit of a pain but it does make things simpler and it means that I'm not responsible for protecting your credentials, although if you are using HTTP Basic Authentication there is a good chance your credentials aren't very well protected anyway.

AuthHMAC authentication

As of version 0.5.1 rAtom also support authentication via HMAC request signing using the AuthHMAC gem. This is made available using the :hmac_access_id and :hmac_secret_key parameters which can be passed to the same methods as the HTTP Basic credentials support.


As of version 0.6.9, rAtom supports fetching feeds via https. This is done by using URLs with the SSL protocol. Publishing support is still limited to http, but patches are welcome.


Support partial content responses from the server.

Support batching of protocol operations.

All my tests have been against internal systems, I'd really like feedback from those who have tried rAtom using existing blog software that supports APP.

Handle all base uri tests.

Add slug support.

Source Code

The source repository is accessible via GitHub:

git clone git://

The project now uses Bundler for dependency management so, just do

bundle install

to get going.

Contact Information

The project page is at Please file any bugs or feedback using the trackers and forums there.

Authors and Contributors

rAtom was developed by Peerworks and written by Sean Geoghegan.

Author: Seangeo
Source Code: 
License: MIT license

#ruby #atom #xml 

Ratom: A Fast, Libxml Based, Ruby Atom Library
Nat  Grady

Nat Grady


Atom: The Hackable Text Editor


Atom and all repositories under Atom will be archived on December 15, 2022.

Atom is a hackable text editor for the 21st century, built on Electron, and based on everything we love about our favorite editors. We designed it to be deeply customizable, but still approachable using the default configuration.


Atom Screenshot

Visit to learn more or visit the Atom forum.

Follow @AtomEditor on Twitter for important announcements.

This project adheres to the Contributor Covenant code of conduct. By participating, you are expected to uphold this code. Please report unacceptable behavior to


If you want to read about using Atom or developing packages in Atom, the Atom Flight Manual is free and available online. You can find the source to the manual in atom/

The API reference for developing packages is also documented on




Download the latest Atom release.

Atom will automatically update when a new release is available.


Download the latest Atom installer. AtomSetup.exe is 32-bit. For 64-bit systems, download AtomSetup-x64.exe.

Atom will automatically update when a new release is available.

You can also download (32-bit) or (64-bit) from the releases page. The .zip version will not automatically update.

Using Chocolatey? Run cinst Atom to install the latest version of Atom.


Atom is only available for 64-bit Linux systems.

Configure your distribution's package manager to install and update Atom by following the Linux installation instructions in the Flight Manual. You will also find instructions on how to install Atom's official Linux packages without using a package repository, though you will not get automatic updates after installing Atom this way.

Archive extraction

An archive is available for people who don't want to install atom as root.

This version enables you to install multiple Atom versions in parallel. It has been built on Ubuntu 64-bit, but should be compatible with other Linux distributions.

Install dependencies (on Ubuntu):

sudo apt install git libasound2 libcurl4 libgbm1 libgcrypt20 libgtk-3-0 libnotify4 libnss3 libglib2.0-bin xdg-utils libx11-xcb1 libxcb-dri3-0 libxss1 libxtst6 libxkbfile1

Download atom-amd64.tar.gz from the Atom releases page.

Run tar xf atom-amd64.tar.gz in the directory where you want to extract the Atom folder.

Launch Atom using the installed atom command from the newly extracted directory.

The Linux version does not currently automatically update so you will need to repeat these steps to upgrade to future releases.



Learn more in our official announcement

Author: Atom
Source Code: 
License: MIT license

#electron #javascript #atom #windows #macos #linux 

Atom: The Hackable Text Editor

Gounit: Unit Tests Generator for Go Programming Language


GoUnit is a commandline tool that generates tests stubs based on source function or method signature.




go get -u

Usage of GoUnit

This will generate test stubs for all functions and methods in file.go

  $ gounit gen -i file.go 

Run gounit help for more options

Custom test templates

If you're not satisfied with the code produced by the default GoUnit test template you can always write your own! You can use minimock template as an example. Here is how to add and switch to the custom template:

  $ curl > minimock
  $ gounit template add minimock
  $ gounit template list

    gounit templates installed

       * default

  $ gounit template use minimock

Minimock template produces test stubs that are aware of the mocks generated by the minimock mock generator. By using both of these tools you can automate the process of writing tests and focus on your test cases rather than routine operations.

Integration with editors and IDEs

To ease an integration of GoUnit with IDEs "gen" subcommand has a "-json" flag. When -json flag is passed GoUnit reads JSON requests from Stdin in a loop and produces JSON responses with generated test(s) that are written to Stdout. Using this mode you can generate as many tests as you want by running GoUnit executable only once.

There are plugins for

Author: Hexdigest
Source Code: 
License: View license

#go #golang #vim #atom 

Gounit: Unit Tests Generator for Go Programming Language

Go-plus: An Enhanced Go Experience for The Atom Editor


An Improved Go Experience For The Atom Editor



This package includes the following functionality:

  • Display information about your current go installation, by running go version and go env
  • Autocomplete using gocode
  • Format your code with gofmt, goimports, or goreturns; optionally run one of these tools on save of any .go file
  • Run go install . and go test -c -o {tempdir} . to verify your code compiles and to keep gocode suggestions up to date
  • Run a variety of linters (e.g. golint, vet, etc.) against your code using gometalinter, revive or golangci-lint
  • Run tests, display test output, and display test coverage using go test -coverprofile
  • Display documentation for identifiers in source code using gogetdoc
  • Rename the symbol under your cursor using gorename
  • Go to definition using guru or godef
  • Highlight occurrences of an identifier using guru
  • Find usages of an identifier using guru

You can add debug functionality to Atom by installing the following package:


How Are The Builds Performed?

The following commands are run for the directory of the current file:

  • go install . (for normal .go files)
  • go test -o {tmpdir} -c . (for _test.go files)

Why Are You Running go install Instead Of go build?

gocode (and a few other tools, like gotype) work on .a files (i.e. the package object archive), and the way to keep these up to date is to run go install periodically. This ensures your autocomplete suggestions are kept up to date.


The package has CI for OS X, Windows and Ubuntu.

Installing Missing Tools

If you are missing any required tools, you may be prompted to install them. You can also manually install the required tools in your terminal:

go get -u
go get -u
go get -u
go get -u
go get -u
go get -u
go get -u
go get -u
go get -u
go get -u
go get -u
go get -u
go get -u
go get -u

Having Issues?

Please consult the FAQ prior to opening an issue:

If you have an issue with debugging, file an issue with go-debug here.



A list of contributors can be found at Thank you so much to everyone has contributed to the package :heart:. You are awesome!


Contributions are greatly appreciated. Please fork this repository, make your changes, and open a pull request. See Contributing for detailed instructions.

Author: joefitzgerald
Source Code: 
License: View license

#go #golang #editor #atom 

Go-plus: An Enhanced Go Experience for The Atom Editor
Awesome  Rust

Awesome Rust


Atom Ide Rust: Rust IDE Support for Atom


Rust language support for Atom-IDE, powered by rust-analyzer.


  • Auto-completion
  • Diagnostics (errors and warnings from rustc)
  • Document outline
  • Go to definition (ctrl or cmd click)
  • Type information and Documentation on hover (hold ctrl or cmd for more information)
  • Find references (ctrl-alt-shift-f or cmd-opt-shift-f also in context menu)
  • Format file with rustfmt (ctrl-shift-c or cmd-shift-c also in context menu)
  • Format on save (disabled by default, see atom-ide-ui settings)
  • Rustup toolchain update checking at startup & every 6 hours thereafter
  • Supports rustup override toolchains
  • Rust language snippets


Install from Settings view by searching for ide-rust, or with the command line:

$ apm install ide-rust


rust-analyzer must be installed manually, if possible on the PATH (otherwise configure this in the package settings). See

NOTE: On Windows, you can install it using choco: choco install rust-analyzer

No other packages or manual setup is required as these will be handled with user prompts after install. However, you may wish to install rustup with your OS package manager instead of following prompts to install via

Configure rust-analyzer

rust-analyzer settings can be stored in a JSON file in the project directory.

It first looks for rust-analyzer.json. If the file does not exists, it then checks .config/rust-analyzer.json.

Refer to the rust-analyzer User Manual for the supported config options.


enable proc-macro support (from the User Manual)

    "cargo": {
        "loadOutDirsFromCheck": true,
    "procMacro": {
        "enable": true,

configure rust-fmt

    "rustfmt": {
        "extraArgs": ["+nightly"]


  • ide-rust:restart-all-language-servers Restart all currently active Rls processes

Debugging IDE-Rust

If stuff isn't working you can try enabling logging to debug:

  • Open the atom console (ctrl-shift-i)
  • Enter atom.config.set('core.debugLSP', true)
  • Reload atom (ctrl-shift-F5)

This will spit out language server message logging into the atom console. Check if requests/responses are being sent or are incorrect.


RLS is no longer supported. To use RLS install a previous version of ide-rust, apm install ide-rust@0.21.2.



Autocomplete image


Datatips image


Linter image


Outline image

Download Details:
Author: rust-lang
Source Code:
License: MIT License

#rust  #rustlang  #ide #javascript #atom 

Atom Ide Rust: Rust IDE Support for Atom
Gordon  Taylor

Gordon Taylor


Language-babel: ES2017, Flow, React JSX & GraphQL Grammar


Language grammar for all versions of JavaScript including ES2016 and ESNext, JSX syntax as used by Facebook React, Atom's etch and others, as well as optional typed JavaScript using Facebook flow. This package also supports highlighting of GraphQL language constructs when inside certain JavaScript template strings. For .graphql and .gql file support please see language-graphql . The colour of syntax is determined by the theme in use.

The package also provides

By default the language-babel package will detect file types .js,.babel,.jsx, .es, .es6, .mjs and .flow. Use the standard ATOM interface to enable it for other file types. This provides a grammar that scopes the file in order to colour the text in a meaningful way. If other JavaScript grammars are enabled these may take precedence over language-babel. Look at the bottom right status bar indicator to determine the language grammar of a file being edited. language-babel will be shown as either Babel or Babel ES6 JavaScript. Clicking the name will allow the grammar for a file to be changed.

language-babel provides Babel V6 & V5 transpiler support. If you only require grammar/syntax highlighting ensure that the package settings Transpile On Save and Allow Local Override are both off.


Install via ATOM or by using apm install language-babel. If you only need to use the provided grammar read no further!

Auto Completion of JSX tags, elements and attributes

JSX tag closures are provided as auto-complete options. In addition, common HTML elements and their associated properties are displayed as auto-complete lists. Those supported by language-babel are described here


Commenting out JSX elements

JSX elements cannot be commented out by using standard // or /* */ commenting. Normally {/* */} is used instead. language-babel changes the Atom toggle comments behaviour when inside a JSX block to support this behaviour. Nested elements within JSX that require a // form of commenting will be detected automatically.


Automatic insertion between JSX tags

When a newline is inserted between a matched open/close pair of JSX tags, language-babel inserts an additional line and positions the cursor. If Auto Indent is also turned on then the cursor is correctly indented.


Automatic Indenting of JSX

The package setting Auto Indent JSX if enabled will auto-indent any JSX code typed or moved across using suitable Atom defaults. There are also three commands - language-babel:toggle-auto-indent-jsx, language-babel:auto-indent-jsx-on and language-babel:auto-indent-jsx-off that override the default behaviour. These can be mapped to keyboard shortcuts if needed.

Auto-Indenting will also attempt to read the .eslintrc file associated with an edited file's project for the presence of four properties whose defaults are shown below. These rules, which are part of the ESLint-plugin-React EsLint plugin, are then used to determine the alignment and tab/spaces spacing of JSX elements. For more information on the options for these rules see Closing bracket, Indent and Indent Props.

Please note that no attempt is currently made to read eslint settings in any other file. e.g. package.json, eslint.js, extends..., etc.

  "rules": {
    "indent": 1,
    "react/jsx-closing-bracket-location": 1,
    "react/jsx-indent-props": 1,
    "react/jsx-indent": 1

When moving around a JSX block language-babel reformats the preceding JSX lines automatically. Lines following the cursor are not indented. This is to protect the source code following incomplete JSX from being processed. The user should correctly position the first JSX element as auto-indenting will not do this.

You may also turn off automatic indenting for all files by setting the package option Auto Indent JSX


Interface to Babel v7, v6 & v5.

language-babel fully supports the Babel JavaScript transpiler versions 5, 6 and 7.

Options in the language-babel package settings and/or in .languagebabel project based JSON files allow for Babel validations to be carried out on a file saves using .babelrc options. A file tree context menu - Language-Babel - is also provided that allows whole directories to be transpiled obeying any .babelrc and .languagebabel settings. Even if using a workflow such as gulp, webpack, etc, this can be very useful. Additional options allow the output from Babel (transpiled code and maps ) to be output to other directories.

It is also possible to preview any source file as Babel would output it.


Babel code can be previewed as shown below. Source mapping keeps the ES201x file's cursor in step with the transpiled code's cursor. This feature requires the Atom package source-preview in which language-babelbecomes a provider of transpiled output which source-preview consumes.

Please note that the following two packages should be disabled or uninstalled to stop multiple packages contending for the same transpile - source-preview-babel and source-preview-react.

source-preview provides a keyboard toggle to view the current file. As with transpiling described below, a project must have the relevant .babelrc, package.json and node_modules



This package works by using the concept of a project folder which we assume contains a project or even nested projects any of which may contain a Babel project. In a Babel project, we expect to see one or more .babelrc files, node_modules folders at the root's of the project containing an optional @babel/core babel-core and other babel plugins/presets as determined by the project's package.json file. In addition, we may expect to see one or more .languagebabel files in the project. Projects are either implicit (an Atom project folder) or explicit (denoted by a .languagebabel property of "projectRoot": true). If no @babel/core or babel-core is found in the project then a check is made to determine if this is part of a Yarn workspace and if so a further check is made in the workspace node_modules for @babel/core or babel-core. If none are found then a version will be provided by language-babel but this will be a Babel Version 6 instance. Plugins and presets will not be provided by the package.

A trivial example project that shows examples of using .languagebabel and .babelrc files may be found here.


Multiple projects may be open at any time inside Atom and language-babel must allow the use of differing babel-core versions and associated plugins when transpiling. It does this by using background tasks - one per Babel project. When a language-babel grammar enabled file is saved the package settings and optionally any .languagebabel configuration files are read to determine if the file should be transpiled and what to do with the output. These settings and .languagebabel options are described below.

It is very easy to ensure that language-babel does not transpile files that are not needed. Just turn off the global package setting Transpile On Save and turn on Allow Local Override. Apart from grammar highlighting only projects having a .languagebabel in the file path will then be affected by this package. Further granularity is easy too.

If .babelrc and/or package.json files contain Babel properties that are environment specific these environments should be created before Atom is started. In particular, Babel assumes a development environment by default, whereas Atom assumes a production environment by default.



set NODE_ENV="development"



Package Settings

For most projects, it is better to configure language-babel via project-based .languagebabel file properties which will override the package settings below. See ".langeuagebabel Configuration" for more information on this behaviour.

Allow Local Override

If set this allows .languagebabel file properties to override the global package settings.

Transpile On Save

On any file save of a language-babel grammar enabled file the Babel transpiler is called. No actual transpiled file is saved but any Babel errors and/or successful indicators are notified by an ATOM pop-up. Not all files are candidates for transpilation as other settings can affect this. For example see Disable When No Babelrc File In Path and Babel Source Path below.

{"transpileOnSave": true} or
{"transpileOnSave": false}

Create Transpiled Code

If enabled together with Transpile On Save this will output JavaScript code to a .js file with the same prefix as the original. By using the Babel Transpile Path options it is possible to transpile to a different target directory. Not all files are candidates for transpilation as other settings can affect this.

{"createTranspiledCode": true} or
{"createTranspiledCode": false}

Disable When No Babelrc File In Path

Disables transpiler if no .babelrc files are found in the source file path.

{"disableWhenNoBabelrcFileInPath": true} or
{"disableWhenNoBabelrcFileInPath": false}

Suppress Transpile On Save Messages

Suppress all successful save messages. Errors are still notified.

{"suppressTranspileOnSaveMessages": true} or
{"suppressTranspileOnSaveMessages": false}

Suppress Source Path Messages

This is set by default so that when a file is saved that is outside the Babel Source Path directory no message is generated. This is particularly useful when you have mixed ES2015 and ES3-5 environment. ES2015 files can be placed inside a Babel Source Path where they will be transpiled and other files will not pop up annoying messages when being saved.

{"suppressSourcePathMessages": true} or
{"suppressSourcePathMessages": false}

Create Map

If transpiled output is being saved a separate source map can be also be saved. The source file name will be used with a new suffix of and sent to a directory specified in Babel Maps Path.

If .babelrc files use the sourceMaps: inline or sourceMaps both option, turn this createMap option off as the map data is stored as part of the source file.

{"createMap": true} or
{"createMap": false}

Babel Maps Add Url

If a source map is created using the Create Map option above then this appends a Url reference //# to the transpiled JavaScript file.

{"babelMapsAddUrl": true} or
{"babelMapsAddUrl": false}

Project Root ( only present in .languagebabel files)

A .languagebabel property that defines this directory is a project root. A project root would contain a node_modules folder with an optional babel-core as well as any plugins required.

{"projectRoot": true} or
{"projectRoot": false}

Babel Source Path, Babel Transpile Path and Babel Maps Path

These a directories based on the project root. A project root is either implicit ( based on an Atom folders root directory) or explicit ( based upon the root defined in the nearest .languagebabel file with a property "projectRoot": true )

Only files found under the project/babelsourcepath will be candidates for transpilation. If multiple project root folders exist then babelsourcepath may exist in any or all folders.

The Transpile and Maps paths allow different target directories to be specified. If multiple project root folders exist then they may exist in any or all folders.

e.g. Two project root folders exist /proj1 and /proj2. If Source Path is set to babelSourcethe Transpile Path is set to babelTranspile and the Maps Path is set to babelMaps then:-

/proj1/babelSource/foo.es6 ->/proj1/babelTranspile/foo.js,/proj1/babelMaps/

  "projectRoot":  true,    
  "babelSourcePath": "babelSource",
  "babelTranspilePath": "babelTranspile",
  "babelMapsPath": "babelMaps"

/proj2/babelSource/dirBar/foo.es6 -> /proj2/lib/foo.js,/proj2/lib/

  "projectRoot":  true,
  "babelSourcePath": "babelSource/dirBar",
  "babelTranspilePath": "lib",
  "babelMapsPath": "lib"

Create Target Directories

When enabled any target directories that do not exist will be created prior to a transpilation.

{"createTargetDirectories": true} or
{"createTargetDirectories": false}

Keep File Extension

Keeps the source filename extension as the target filename extension

Auto Indent JSX

Enables automatic indenting of JSX.

JavaScript Tagged Template Literal Grammar Extensions

This package setting allows language-babel to include third party grammars to highlight code inside template literal strings. These may be tagged template literals, described here, or where no appropriate function tag exists, another form of tag marking that signifies the templates nature. e.g. A comment string.

For example you may wish to highlight templates prefixed with /* @html */`<div></div>` as HTML, and maybe sql`select * from table foo` as SQL. The latter assumes a tagged function named sql exists in the code.

In order to do this, you need to find a language package that supports the highlighting of the template code. This language package should then be installed into Atom. You then need to find the scope name for that grammar. This can be done in a number of ways, but if you view the grammars JSON/CSON file and look for the scopeName property field, this indicates the scope name for that grammar.

If we use the Atom provided languages language-css, language-html and language-sql in our example above to highlight the template code, then this field would look like.

"(?:css\.(?:[a-z])+)":source.css, /* @html */:text.html.basic, sql:source.sql

In other words, the package settings for this field is an array of strings, with each string in the form of template-prefix:grammar-scopename#optional-include.


  • template-prefix is a literal string or an Oniguruma regular expression ( Oniguruma is the regular expression engine for TextMate grammars used by Atom) that comes before the opening back-tick of a template. A literal string may contain any characters except a comma but including colons. A regular expression is denoted by being enclosed by double quote marks "RegExp Here". Most importantly, a regular expression should create no capturing groups.
  • :The last colon in the string signifies the start of the embedded grammars scopeName.
  • grammar-scopename is the scopeName of the grammar used to highlight the template.
  • #optional-include if present, will use that include block in the grammars repository.

Styled-Components Auto-Complete Method

This flag if set will enable Emmet snippets to be used inside CSS templates. If a valid emmet abbreviation is entered then the expanded snippet will appear at the top of a auto-complete list. Pressing the appropriate auto-complete key (normally tab) will expand the snippet.

.languagebabel Configuration

.languagebabel JSON configuration files can exist in any directory of the path that contains a source file to be compiled. The properties in this file override the global package settings above. If .languagebabel files are present, they read and merged starting in the source files directory up to the project root directory. Properties defined closest the source file take precedence.

To use this option please enable the Allow Local Override package setting.

A .languagebabel file may contain one or more of the following properties.

  "babelMapsPath":                    "relPath",
  "babelMapsAddUrl":                  true|false,
  "babelSourcePath":                  "relPath",
  "babelTranspilePath":               "relPath",
  "createMap":                        true|false,
  "createTargetDirectories":          true|false,
  "createTranspiledCode":             true|false,
  "disableWhenNoBabelrcFileInPath":   true|false,
  "keepFileExtension":                true|false,
  "projectRoot":                      true|false,  
  "suppressSourcePathMessages":       true|false,
  "suppressTranspileOnSaveMessages":  true|false,
  "transpileOnSave":                  true|false

GraphQL Code Highlighting

language-babel supports highlighting of GraphQL code within JavaScript files. For highlighting .graphql and .gql files see its sister grammar - language-graphql.

Inside JavaScript, GraphQL enclosed in back-ticks, a.k.a. Quasi or template strings are highlighted. Other GraphQL structures, notably types, are supported by the Flow component of this package.

Strings that have one of three prefixes/tags are parsed by the grammar to highlight the code enclosed.

Relay.QL`This is how Relay uses template strings`

graphql`This is how Relay will use template strings`

gql`This is how Apollo for GraphQL uses template strings`

/* GraphQL */`For cases where no template tag function is available`


An example of using the third method for highlighting code using /* GraphQL */

var { graphql, buildSchema } = require('graphql');

var schema = buildSchema(/* GraphQL */`
  type Query {
    hello: String

Author: Gandm
Source Code: 
License: MIT License

#es6 #javascript #react #atom #graphql 

Language-babel: ES2017, Flow, React JSX & GraphQL Grammar

Solidity Ethereum Tutorial: Truffle, Atom and TestRPC

Truffle is a world-class development environment, testing framework and asset pipeline for blockchains using the Ethereum Virtual Machine (EVM), aiming to make life as a developer easier. Truffle is widely considered the most popular tool for blockchain application development with over 1.5 million lifetime downloads.

Ethereum IDE plugin for hackable Atom editor. Compile smart contracts, deploy them to Ethereum networks. Efficient contract management interface. Integrated test suite for smart contracts.

testrpc is a Node. js based Ethereum client for testing and development. It uses ethereumjs to simulate full client behavior and make developing Ethereum applications much faster. It also includes all popular RPC functions and features (like events) and can be run deterministically to make development a breeze.

Test RPC:

Source code :

#solidity  #blockchain  #ethereum #truffle #TestRPc #atom 

Solidity Ethereum Tutorial: Truffle, Atom and TestRPC
Reid  Rohan

Reid Rohan


Atom-ava: Snippets for AVA and Run Tests Directly in The Editor


Snippets for AVA and run tests directly in the editor


$ apm install ava

Or, Settings → Install → Search for ava


Included are some snippets useful for writing AVA tests.

Start writing a snippet's prefix and then press Tab ↹ to expand the snippet.

Snippets are fuzzy matched, so you can for example just write tde to get the t.deepEqual() snippet.

Run tests directly in the editor

In a project, choose the Ava: Run command in the Command Palette or press Ctrl Alt A to run the tests. Choose Ava: Run File or press Ctrl Alt Shift A to only run the current test file. Press Esc to close the AVA panel.


Author: Avajs
Source Code: 
License: MIT License

#javascript #ava #atom 

Atom-ava: Snippets for AVA and Run Tests Directly in The Editor
Diego  Elizondo

Diego Elizondo


12 Paquetes Atom Esenciales Para El Desarrollo Web

En este artículo, profundizaremos en 12 de los mejores paquetes Atom para desarrolladores web. Atom tiene mucha competencia, incluidos Visual Studio Code y Sublime Text, pero aún se mantiene como una herramienta de desarrollo web popular y competente.

¿Por qué usar el Editor Atom?

Es posible que VS Code se haya ganado los corazones y las mentes de los desarrolladores web en los últimos años, pero el editor Atom de GitHub sigue siendo uno de los mejores y más capaces editores de código del mercado. Las razones para que me guste mucho incluyen:

  • los instaladores están disponibles para Windows, Mac y Linux
  • se ha actualizado continuamente durante la última década
  • la velocidad ha mejorado después de algunas críticas a los lanzamientos iniciales
  • todavía es gratis para descargar y usar sin restricciones ni pantallas molestas

Microsoft adquirió GitHub en 2018, por lo que la empresa ahora tiene dos buenos editores de código basados ​​en Electron. El futuro a largo plazo de Atom probablemente esté en duda, pero el desarrollo continúa. Si está buscando un nuevo editor de código, quizás después de que Adobe abandonó Brackets , Atom debería estar en la parte superior de su lista.

Paquetes y temas de Atom

Atom siempre se ha promocionado como un "editor de texto pirateable para el siglo XXI". La instalación básica tiene comparativamente pocas funciones, pero puede ampliarla con complementos conocidos como paquetes .

En el momento de escribir este artículo, hay disponibles más de 3000 temas Atom y 9000 paquetes Atom. Parte de la razón de esto es que Atom se puede ampliar mediante tecnologías web. Si es un desarrollador de Node.js o JavaScript del lado del cliente, sabe lo suficiente como para crear sus propios paquetes Atom y mejorar Atom de la forma que desee.

Cómo instalar paquetes Atom

Agregar paquetes Atom es bastante simple, ya que Atom viene con un administrador de paquetes incorporado. (Muchos desarrolladores se sienten atraídos por Atom en parte porque es muy fácil instalar paquetes Atom).

Abra el editor Atom, haga clic en el menú Editar en la barra de navegación superior y luego seleccione Preferencias . Se abrirá una nueva pestaña de Configuración . Haga clic en el elemento de menú + Instalar y aparecerá un campo de búsqueda a la derecha. Esto le permitirá buscar nuevos paquetes Atom por nombre. Cuando haya localizado el paquete Atom que desea, presione el botón Instalar .

Instalar paquetes Atom

Al hacer clic en el elemento del menú Paquetes , verá qué paquetes Atom están instalados actualmente. Todo lo que haya instalado usted mismo aparecerá en el elemento del menú Paquetes de la comunidad . Notará que también hay un elemento de menú Paquetes básicos . Esto enumera los paquetes instalados por defecto. Puede deshabilitarlos si lo desea, pero es mejor no hacerlo, ya que esto afectará la funcionalidad básica del editor.

Paquetes Atom instalados

Instalación de paquetes Atom desde la línea de comandos

Atom también viene con una herramienta de línea de comandos llamada apm(que significa Atom Package Manager). También puede usar esta herramienta para instalar paquetes directamente desde la terminal.

La sintaxis es la siguiente: apm install <package-name>.

Puede configurar apmutilizando la apm configopción de línea de comandos o editando manualmente el ~/.atom/.apmrcarchivo. Escribir apm helple dará una idea de qué más puede hacer.

Y dicho esto, aquí hay doce de los mejores paquetes de Atom, además de algunas opciones de bonificación , que hacen de Atom un editor de código aún mejor...

1. Iconos de archivo

Los iconos de archivos y carpetas predeterminados de Atom se describen mejor como "funcionales". Un conjunto de iconos como este file-iconsmejora la apariencia del editor y facilita la localización de archivos de un tipo específico.


Busque "icono" en el panel + Instalar para encontrar docenas de opciones alternativas.

2. Gerente de Proyecto

Atom proporciona una gestión de proyectos sencilla basada en carpetas. Es lo suficientemente bueno si está cambiando entre un par de proyectos, pero project-manageres ideal para algo más sofisticado. Ofrece opciones de paleta de comandos y un archivo JSON editable donde puede definir proyectos y con sus propias configuraciones personalizadas, como colores, preferencias de pestañas, etc.

El complemento del paquete del administrador de proyectos Atom

3. Ajustes de sincronización

Si está ejecutando Atom en más de un dispositivo, es útil sincronizar la configuración, las combinaciones de teclas y los fragmentos entre instalaciones. Puede sincronizar manualmente mediante la clonación de archivos en la carpeta Config ( Configuración , luego Abrir carpeta de configuración ), pero sync-settingsproporciona una opción automatizada más sencilla. La configuración se guarda en Gist, pero otros paquetes de Atom le permiten elegir una carpeta local o un repositorio de Git .

  • Obtenga el paquete de configuración de Atom Sync aquí : sync-settings

4. Todo Mostrar

Comenzó Atom, abrió una carpeta y luego... ¿qué sigue? El todo-showpaquete Atom revela comentarios dispersos por su proyecto que contienen palabras clave como y TODO, pero también puede agregar sus propias expresiones regulares.FIXMECHANGED


  • Obtenga el paquete Atom Todo Show aquí : todo-show

5. Minimapa

minimapes uno de los paquetes Atom más populares, con más de siete millones de descargas. Muestra una vista condensada de su código en el lado derecho de la ventana del editor de código, lo cual es de gran ayuda para una navegación rápida. Esta característica entra en tu subconsciente; no pensarás que lo estás usando, pero lo extrañarás cuando no esté allí.


Obtenga el paquete Atom Minimap aquí : minimapa

6. Resaltar seleccionado

Cuando selecciona una palabra clave o variable en VS Code, Sublime Text o Notepad ++, resalta todas las demás instancias. highlight-selectedtrae esa característica a Atom y es aún mejor cuando se combina con minimap-highlight-selected:

resaltado seleccionado

7. HTML de cierre automático

Como sugiere el nombre, este paquete agregará automáticamente una etiqueta HTML de cierre cuando complete la etiqueta de apertura. Este puede ser un paquete simple, ¡pero no puedo arreglármelas sin las etiquetas HTML de cierre automático! autoclose-htmlduplica la velocidad de creación de marcado. Funciona de forma inmediata, pero el paquete también le permite definir qué etiquetas deben completarse en línea (como <p></p>o <li></li>) y cuáles deben crear bloques de nueva línea (como <article> ... </article>o <ol> ... <ol>).

8. Pigmentos

La mayoría de los editores tienen visualizadores de colores CSS, pero pocos coinciden con el pigmentspaquete de Atom. Analiza colores, propiedades personalizadas de CSS, variables de preprocesador e incluso ejecuta funciones de cambio de color como lighten()y darken(). Escanea sus archivos de origen para crear una paleta de colores para que pueda hacer referencia a ellos en cualquier lugar.


  • Obtenga el paquete Pigments Atom aquí : pigmentos

Además, el paquete Color Picker es para cualquiera que prefiera seleccionar colores en lugar de recordar sus nombres o valores hexadecimales.

9. pelusa

Puede ejecutar linters desde la línea de comandos, pero no es tan rápido ni efectivo como la validación de código en vivo en el editor. Linter es uno de los mejores. Es rápido y menos intrusivo que algunos competidores.

Tenga en cuenta que Linter es el paquete principal de Atom que proporciona una API para docenas de lenguajes de programación . Algunos, como HTML y CSS, no requieren software adicional. Otros, como eslint, requieren el módulo Node y los ajustes de configuración (se proporcionan instrucciones completas).

Linear su código mejorará en gran medida la calidad de su código, por lo que lo animo a que lo pruebe.

10. Detección automática de sangría

Los programadores nunca se pondrán de acuerdo sobre si usar tabulaciones o espacios. Incluso cuando lo hacen, pueden preferirlos en sabores de dos, cuatro u ocho caracteres. Por lo general, opto por lo que molesta a la mayoría de las personas (¿pestañas duras de tres caracteres?), Pero auto-detect-indentationfunciona con lo que requiere el proyecto para que nunca tenga que preocuparse por eso.

Alternativamente, puede forzar el código de todos para que coincida con su estilo preferido usando Atom Beautify:

11. Teletipo

Si alguna vez usó Live Share para VS Code , comprenderá cómo ha revolucionado la programación en pareja. La extensión permite que dos personas editen código de forma remota en el mismo espacio de trabajo al mismo tiempo.

teletypees el paquete equivalente para Atom. Es un servicio beta, pero se ve bien y parece confiable.

  • Obtenga el paquete Atom Teletype aquí : teletipo

12. Más paquetes Atom

Hemos cubierto lo que son, en mi opinión, algunos de los mejores paquetes Atom. Terminaremos con algunas menciones especiales que no llegaron a la lista principal pero que aún son realmente útiles y vale la pena mirar.

  • Emmet (anteriormente conocido como Zen Code) puede expandir expresiones similares a CSS en etiquetas HTML: emmet
  • Si está creando servicios web REST, el cliente REST de Atom proporciona una herramienta de prueba HTTP rápida. No es rival para alternativas poderosas como Postman , pero es ideal para pruebas rápidas y sucias: rest-client


  • Finalmente, no hay necesidad de buscar actualizaciones manualmente. auto-update-packagesverifica sus paquetes cada seis horas y hace el trabajo por usted: paquetes de actualización automática

Complementos fuera de horario

Si su conteo de llaves ( keycount ) demuestra que ha hecho suficiente por el día, relájese leyendo cómics xkcd o juegue un juego rápido de Tetris , Reversi , Pong , Snake o SimCity .


¿Me he perdido tu complemento Atom favorito?  


#web #atom #packaging #developer 

 12 Paquetes Atom Esenciales Para El Desarrollo Web
坂本  健一

坂本 健一



この記事では、Web開発者向けの最高のAtomパッケージの12を掘り下げます。Atomには、Visual StudioCodeやSublimeTextを含む多くの競争がありますが、それでも人気のある有能なWeb開発ツールとしての独自性を保持しています。


VS Codeは、過去数年にわたってWeb開発者の心をつかんだかもしれませんが、GitHubのAtomエディターは、市場でより優れた、より有能なコードエディターの1つです。それをとても好きな理由は次のとおりです。

  • インストーラーは、Windows、Mac、およびLinuxで使用できます
  • 過去10年間にわたって継続的に更新されています
  • 初期リリースに対する批判を受けて、速度が向上しました
  • 制限やナグスクリーンなしでダウンロードして使用することはまだ無料です







Atomエディターを開き、上部のナビゲーションバーの[編集]メニューをクリックして、[設定]を選択します。新しい[設定]タブが開きます。[ +インストール]メニュー項目をクリックすると、右側に検索フィールドが表示されます。これにより、新しいAtomパッケージを名前で検索できるようになります。目的のAtomパッケージを見つけたら、[インストール]ボタンを押します。





apmAtomには、(Atom Package Managerの略)というコマンドラインツールも付属しています。このツールを使用して、ターミナルから直接パッケージをインストールすることもできます。

構文は次のとおりですapm install <package-name>

apmコマンドラインオプションを使用するapm configか、ファイルを手動で編集して構成でき~/.atom/.apmrcます。入力apm helpすると、他に何ができるかがわかります。





  • ここからファイルアイコンパッケージを入手してくださいfile-icons





  • ここでAtomプロジェクトマネージャーパッケージを入手してくださいproject-manager


複数のデバイスでAtomを実行している場合は、インストール間で設定、キーバインディング、およびスニペットを同期すると便利です。Configフォルダー( [設定][Configフォルダーを開く])のファイルのクローンを作成することで手動で同期できますがsync-settings、より簡単な自動オプションが提供されます。設定はGistに保存されますが、他のAtomパッケージでは、ローカルフォルダーまたはGitリポジトリを選択できます。

  • ここからAtom同期設定パッケージを入手してくださいsync-settings




  • ここでAtomTodoShowパッケージを入手してくださいtodo-show






VS Code、Sublime Text、またはNotepad ++でキーワードまたは変数を選択すると、他のすべてのインスタンスが強調表示されます。highlight-selectedその機能をAtomにもたらし、以下と組み合わせるとさらに優れたものになりminimap-highlight-selectedます。



名前が示すように、このパッケージは、開始タグを完了すると、終了HTMLタグを自動的に追加します。これは単純なパッケージかもしれませんが、HTMLタグを自動で閉じることなしに対処することはできません!autoclose-htmlマークアップの作成速度が2倍になります。箱から出してすぐに機能しますが、パッケージでは、インラインで完了するタグ(<p></p>または<li></li>)と改行ブロックを作成するタグ(<article> ... </article>または)を定義することもできます<ol> ... <ol>

  • ここでAutoCloseHTML Atomパッケージを入手してくださいautoclose-html




  • ここでPigmentsAtomパッケージを入手してくださいpigments


  • こちらからカラーピッカーパッケージを入手してくださいcolor-picker





  • ここでLinterパッケージを入手してくださいlinter
  • ここでHTMLHintパッケージを入手してくださいlinter-htmlhint
  • ここでAtomCSSLintパッケージを入手してくださいlinter-csslint
  • ここでESLintパッケージを入手してくださいlinter-eslint



または、Atom Beautifyを使用して、全員のコードを好みのスタイルに一致させることもできます。

  • ここでAtomBeautifyパッケージを入手してくださいatom-beautify


Live Share for VS Codeを使用したことがある場合は、それがペアプログラミングに革命をもたらした方法を理解できます。この拡張機能を使用すると、2人で同じワークスペースのコードを同時にリモートで編集できます。


  • ここでAtomテレタイプパッケージを入手してくださいテレタイプ



  • Emmet(以前はZen Codeと呼ばれていました)は、CSSのような式をHTMLタグに拡張できます:emmet
  • REST Webサービスを作成している場合、AtomのRESTクライアントはクイックHTTPテストツールを提供します。Postmanのような強力な代替手段には匹敵しませんが、迅速で汚いテストには最適です:rest-client


  • 最後に、更新を手動で確認する必要はありません。auto-update-packages6時間ごとにパッケージを検証し、作業を行います:auto-update-packages


キーカウント(keycount )で、その日の十分な作業が完了したことが証明された場合は、 xkcdコミックを読んでリラックスするか、テトリスリバーシポンスネーク、またはシムシティの簡単なゲームを楽しんでください。



ソース:https ://

#web  #packaging #atom