PlayStation users who game share are unable to play their PS5 games right now due to the ongoing PSN outage.

PSN Outage Is a Warning to PS5 Users to Change One Console Setting

Solana Mobile has announced the launch of its Seeker web3 smartphone, slated for release in 2025, along with the Play Solana Gen1 gaming console, advancing its efforts to integrate blockchain technology into mobile and gaming platforms.

Solana Introduces Next-Gen Web3 Smartphone, Enters Gaming Market with PSG1 Console - Crypto Daily

Discover the Play Solana Gen1: the first Web3 gaming console on the Solana blockchain…available for pre-order very soon!

Play Solana Launches The PSG1: The First Web3 Gaming Console On Solana!

Video game consoles in general are also described as &quot;dedicated&quot; in distinction from the more versatile personal computer and other consumer electronics. Sanders Associates engineer Ralph H. Baer along with company employees Bill Harrison and Bill Rusch licensed their television gaming technology ...

List of best-selling game consoles - Wikipedia

The Fairchild Channel F, released ... other consoles of the second generation and led to a second boom in the video game industry in the United States and around the globe. During this time, Atari Inc. had been sold to Warner Communications, and due to a change of leadership, several programmers left the company and founded ...

Home video game console - Wikipedia

Console Enterprises (commonly known as Console) is an American technology company headquartered in Chico, California, that focuses on high-performance Android platform design. It is best known for its Console OS Kickstarter campaign, a project intended on developing a native Android distribution ...

Console Enterprises - Wikipedia

Visit the official Nintendo site to shop for Nintendo Switch™ systems and video games, read the latest news, find fun gear and gifts with a Nintendo twist, and much more.

Nintendo Official Site: Consoles, Games, News, and More

Enjoy lifelike gaming audio wherever ... and a companion charging case. ... Get an edge in gameplay with remappable buttons, tuneable triggers and sticks, changeable stick caps, back buttons, and more. ... A highly customisable PlayStation®5 controller kit designed to make gaming more accessible. ... Personalise your PlayStation 5 or PlayStation 5 Digital Edition console with a vibrant ...

PlayStation® Official Site: Consoles, Games, Accessories & More

Ardagh Group produces glass packaging in all shapes and sizes. Glass packaging manufacturers with locations across Africa and beyond.

Glass Packaging Africa | Sustainable Glass Manufacturers Africa

Experience the new generation of games and entertainment with Xbox. Explore consoles, new and old Xbox games and accessories to start or add to your collection.

Xbox Official Site: Consoles, Games, and Community | Xbox

Console

console

Console logs are not always well structured and eye-pleasing. Unpleasant and messy console takes away from the bliss of a developer. I recently came across a package named which does exactly this — making consoles meaningful and elegant. consola It has browser support, pausing and resuming logs, prompt support and . other useful features Installation You can install it by using , or . npm yarn pnpm npm i consola Trying it out Spin up a new and start exploring. node/express app Basics For a quick hands on experience, in your node application, throw an explicit error and then log it with the help of . consola import { consola } from "consola"

try {
 throw Error("Unexpected error")
} catch (error) {
 consola.error(error)
}

consola.error("Error...")
consola.info("Info...")
consola.warn("Warning...")
consola.log("Logged...") New Instance You can create a new consola instance with the help of the method and use that instead of the default global instance. createConsola import { createConsola } from "consola"

const logger = createConsola({
 level: 0, // error/fatal logs
 fancy: true,
 formatOptions: {
 date: true,
 columns: 20
 },
})

logger.info("Info...") // this WON'T work
logger.error("Error...") // this will work Set the log to selectively allow only certain types of logs. of means only and logs are logged. The default log level is 3. level Log level 0 FATAL ERROR Reporters Reporters are representations of logs in the terminal. Consola (v3.2.3) provides 3 out of the box, namely, , and . They are configured based on log levels on the global instance. reporters basic fancy browser consola To add a custom reporter to your newly created instance, you can use the property which is an array of reporters. reporters import { LogLevels, consola, createConsola } from "consola"

const infoLogger = createConsola({
 fancy: true,
 formatOptions: {
 date: true,
 columns: 20
 },
 reporters: [
 {
 log: (log) => {
 if (log.level === LogLevels.info) {
 consola.info(JSON.stringify({
 date: new Date().toLocaleString("default", { dateStyle: "full" }),
 logs: new Array().concat(log.args.map((l, i) => `${l}${i < log.args.length - 1 ? `,` : ``}`)).join(" "),
 }, null, 4))
 } else {
 consola.error(
 new Error("invalid log method")
 )
 }
 }
 }
 ]
}) Now, when you use any logging method on this instance, it will only log for the method and throw an error for other methods. You just created a custom info message logger which you can further modify however you want. info // for the above instance
infoLogger.error("Won't work") ❌
infoLogger.info("Will work") ✔️ Multiple reporters per instance are also supported allowing you to separate logs into desired representations. reporters: [
 {
 log: (log) => {
 if (log.level === LogLevels.info) {
 consola.info(JSON.stringify({
 date: new Date().toLocaleString("default", { dateStyle: "full" }),
 logs: new Array().concat(log.args.map((l, i) => `${l}${i < log.args.length - 1 ? `,` : ``}`)).join(" "),
 }, null, 4))
 } else {
 consola.error(
 new Error("invalid log method")
 )
 }
 }
 },
 {
 log: (log) => {
 createConsola({
 fancy: true,
 formatOptions: {
 date: false
 }
 }).log(log)
 }
 }
] Methods such as , and are available to handle reporters for an instance. addReporter setReporters removeReporter Wrapping native method with instance console consola Doing so will redirect all the native calls to the specified instance. console.log consola infoLogger.wrapConsole()
// consola instance `infoLogger` will print the table
console.table(["Info", "Second Info"]) will restore the native functionality of and won't redirect to consola instance. restoreConsole console.log There are several util methods present in which you can use to further customize the logs. consola/utils Prompts Prompts are supported in consola with the help of , a tool to build command-line apps. Check this out for some . clack prompt examples in consola Conclusion Correctly and elegantly representing console logs is an important task if you want to improve and helps you with just that. developer productivity consola Also published . here

Making Your Console Logs Elegant With Consola

2022 was a tumultuous year for the PC and console games market for , which continues to grow as more gamers are attracted to competitive gaming. In February, Microsoft to bring ‘Call of Duty’ and other Activision games to ’s gaming platform if the Xbox maker is allowed to complete its much-contested US$69 billion acquisition of Activision. Regulators and competitors like Sony are giving much flak to the proposed Microsoft-Activision tie-up. esports struck a 10-year deal Nvidia Meanwhile, Sony’s gaming business is into PC and mobile, as the PlayStation 5 maker vies for talent as industry dealmaking heats up. looking to pour investment According to Newzoo’s , PC and console revenues reached US$92.3 billion in 2022, a decline of -2.2% year on year. The market may be cooling down after the pandemic, but overall performance still outshines previous forecasts. There are still plentiful opportunities to reach over one billion PC players and 611 million console players. 2023 report Player Behaviour The report also reveals that in the last six months, two out of three gamers played on a PC or console, and 72% of PC and/or console players used at least two platforms. The market also became more equitable in 2022, with women gamers accounting for 40% of the total PC and console player base. Playtime data shows that average playtime dropped by 23% across Steam, Xbox, and PlayStation from 2021 to 2022, seen as a corrective step as the market levels out to pre-pandemic activity. In the past six months, 66% of PC and/or console players spent money on video games. Longer game lifespan over new releases According to Newzoo, with the pandemic as a contributing factor, many companies delayed their major title releases from 2022 to at least 2023. These delays significantly impacted playtime and spending, though 2023 now has a packed release schedule, including huge games like . The Legend of Zelda: Tears of a Kingdom In the coming years, companies are expected to opt for fewer new releases and focus on extending the lifespan of existing franchises Essential business model trends show that more game publishers are pivoting their main franchises to service-based and subscription models. In the coming years, companies are expected to opt for fewer new releases and focus on extending the lifespan of existing franchises, especially with the success of titles like Fortnite, Minecraft, and ROBLOX. Gaming & media While remakes and remasters drove up engagement for older game IPs, 2022 was an inflection point for transmedia strategies. The HBO adaptation of was, of course, a major hit and an accelerant for the games, but it was by no means the only example. , the anime based on the controversial title, drastically the franchise’s popularity. The Last of U s Cyberpunk: Edgerunners boosted The behavior of esports gamers is characterized by a high level of engagement and loyalty to the games they play. As a result, esports companies are exploring new ways to engage with these gamers, including sponsorships, influencer marketing, and content creation. One business trend that has emerged is the creation of esports teams and leagues that are backed by major investors and corporations. These teams and leagues are helping to legitimize esports as a mainstream industry and attract a wider audience of fans and investors. This article was originally published by Navanwita Bora Sachdev on The Tech Panda.

Business Trends and Gamer Behavior in Esports on PC and Console

The console object in JavaScript is fundamental piece when we are development ours projects. ‼️ You can go to my to find JavaScript examples. ‼️ Github If we type in our Google Chrome Developer Tools, in the tag, the word: console console you can see that is an object that is inside de global window object: So you can access the console object from the window object. window.console 👓 But is not necessary Let’s get to know her even more: Print in the console: 🔈 _// Printing text_console.log('Hi!'); _// Printing a variable_const PI = Math.PI;console.log(PI); // Expresionsconsole.log(2 + 4);console.log(`PI value: ${PI}`); // Comparingconsole.log(null === undefined);console.log(3 > 2);console.log(typeof NaN);console.log(true || false);console.log(true && false); // Ternary Operatorconsole.log( (3 > 2) ? 'Three!' : 'Two!'); 📍 Result: Print an error: ❌ console.error('Error!'); 📍 Result: Print a warning message: ⚠️ console.warn('Be careful') Examining a object: 🔦 console.dir(document);console.dir({a: 5}); 📍 Result: Assertion: ⛳ function isEqual(x, y) {console.assert(x === y, { "message": "x is not equal than y","x":   x,"y": y });}isEqual(10, 5); Clear: ⬜️ console.clear(); will be the console empty. 📍 Result: Table Output: 📋 const users = [{name: 'Nick', age: 33},{name: 'Jessica', age: 23}];console.table(users); 📍 Result: 〽️ Time: const users = [10, 20, 30];console.time('performance');const gThan10 = users.filter(n => n > 10);console.log(gThan10);console.timeEnd('performance'); 📍 Result: Group: 📦 console.group('numbers');console.log(1);console.log(2);console.log(3);console.groupEnd('numbers'); Thank you 😊!

Discovering the Console in JavaScript

image source: pixel.com logs are one of the most parts of any application. Back in the older days of ObjC, we (developers) didn’t have the tools of beautifying the console logs. However, we could control the verbosity of logs when it comes to extensive debugging. Today, we have some additional features with swift which enable us to do magical stuff with console logs 🎩 Console important Before learning the trick, let’s take an example of default console printing of an object. : Fire up your playground and see yourself 💻 Dev Tip struct User {let firstName: Stringlet lastName: Stringlet age: Int} let user = User(firstName: "John", lastName: "Doe", age: 22)print(user) The example is pretty straightforward of a value type object. Hoping you already know the output: It’s quite obvious that console is giving the information about an object, along with its properties and values (inside the brackets). Instead of the old style of console logging in ObjC, where it used to print the memory reference along with some properties of the object. It’s the time to reshape it 🏋️ CustomStringConvertible Before going into the nitty-gritty of pretty printing, let’s talk about a swift protocol which gives us the power to actually make it happen. is a protocol (blueprint) of converting any instance into a textual representation. Any type conforming to this protocol will leverage its power of custom string representation. Let’s see what’s in there for us. CustomStringConvertible The protocol comes with a requirement, so you need to implement it 👨‍🚀 public var description: String { get } It’s a simple gettable string property that a conforming type will provide, in order use it. Let’s see what happens to User type when it conforms to the protocol: extension User: CustomStringConvertible {var description: String {return """UserfirstName: \(firstName)lastName: \(lastName)age: \(age)"""}} Here, we are trying to translate User to a meaningful printable object using Swift4 multi-line string literal. Hit save ⌨️ That looks 🆒 . Can’t resist adding emojis? Go ahead and add one 😉 Wohoo 🎉 Well, you have then open field to play the way you like it. Create Your Own Printable Protocol Motive; We ain’t gonna repeat this for every other type we have in our project. Are we? 🤔 Swift is a boon 👨‍🔬 It gives you more power than you could imagine. Ever thought of writing your own printable protocol? Let’s dive into it 🏊 Using swift’s protocol inheritance capabilities we are able to create our own printable protocol, which iterates through the class properties to print their respective values. So, instead of conforming to CustomStringConvertible and rewrite the printing, we conform to CustomPrintable protocol to get the desired logs. Awesome isn’t it? 🚀 In the end, adding little sweetness to that (of course emoji 😄) to make it pretty. This can surely improve your dev experience as we all love console logs at all scales. Last but not least, enable your console only for DEBUG mode. Download Playground Example Author🙏 Feedback,👏 and stay tuned for more swifty tricks. Say hello on twitter . @khfarooq Thanks for reading! 🌟

Art of Console Logs ✏️📈

There are certain instances in my childhood that stand out above the rest. A good number of these involve some sort of video game, with my face glued to a screen. One of the earliest games I could remember was , a choose your own adventure game that ran on probably the first computer I ever touched. A few years later, I remember heading to the Toys ‘R’ Us in Sheepshead Bay, where I would make arguably one of the biggest decision a kid in Brooklyn could make in the mid-1990’s — . King’s Quest VI Red version or Blue decisions… decisions… Fast forward to 2017. For the majority of my coding journey, I’ve tinkered with mostly JavaScript-related stuff. Node has been my backend of choice and React has been my favorite library. But when there’s so much excitement about a little thing called Python, that is knowledge I couldn’t ignore. The Python Experiment It’s not all bad, Dr. Jones To be honest, my interest in Python came more from machine learning and data scraping. Beautiful Soup is fantastic, and the ease of the language makes it so much more attractive to use on a backend, despite having more experience in Node. But while Python has all these more practical features, there will always be room for a short project that tugs at my nostalgia. So I took a couple days to try and make a console application. ? The terminal is an oft disregarded program that’s use is either for working with Git (for developers) or for completely ignoring in case you cause your computer to blow up (for the non-techies). Becoming comfortable with the console is what all programmers to strive for, and the lack of a true GUI allows the creator to focus solely on what his or her code is doing, and not how it looks on a particular browser. Why a console application As I scoured the Internet for more examples of what other developers have done in the console, I saw plenty of fantasy-driven storylines, where the hero grabs a sword at some point and fights a dragon. This is all well and good. My original idea was to do something -related. This sort of adventure seemed to fit the bill of a choose your own adventure game. However, the memory of that Toys ‘R’ Us trip in ’97 kept coming back to me. The Legend of Zelda such top-notch graphics right there Making decisions is at the heart of the Pokémon formula. While Link deals with adding inventory and fighting enemies, the basis of Pokémon falls on which creature you’ll start with, and how this decision will impact your future as a trainer. The overall code runs pretty simply. The main() function runs in the bottom of the code, then calls the functions that above it. Each decision is a function that features a future function at the bottom of it. At the moment, it is not the most complicated decision tree, but it manages to currently have over a half-dozen outcomes depending on your choices. The code runs in the terminal with the use of a virtual environment, something that I was unfamiliar with, coming from the JavaScript world. my start screen I had a blast creating this mini-application, but it is, overall, a simple game. There are no classes — this would make a more intricate battle system with hit points and whatnot. Neither am I using to save progress. The game is currently short enough to finish in one setting. While I could continue with the storyline, travel to gyms, and obtain badges, this would best be served in a future application, where I would create my own characters, implement a true battle system, and make use of the creative writing minor I received while at undergrad. Pickle As a lifelong learner and frequent teacher, I will say that creating a fun application like this serves the purpose of teaching without a struggle. More challenging concepts came more naturally because I was having fun. What’s more — seeing the beauty of what Python can create gave me a greater appreciation for JavaScript, a language I’ve played around with all too well, yet never understood how strange it could be when compared with other languages. I even had the pleasure of adding an Easter egg that allows the user to obtain Pikachu as his starting Pokémon. Not bad for a silly console, application, huh? to be honest, I was more of a Charmander-guy growing up Thanks for reading. Feel free to follow , clap for this story, or see more about me . The first chapter of the Pokemon Python source code is here .

Return of the Consoles: Recreating Pokémon in Python

I wanted to write about this ASAP, because I’m curious to know if anyone has done this sort of thing before. Also because I’m excited AF about it. Through a series of accidents, testing, researching, etc, I have discovered that it is possible to use SVG images as a console message. Not only that — you can animate them. Here’s what I’m talking about: My mind was blown when I discovered this. Has anyone seen this sort of thing before? If so, where? Super curious to see what (if anything) someone has done with this. I can’t think of any super applications for doing it — it’s just kind of fun to mess around with. practical I want to share how I did this! I want to share, in hopes that others can explore and see what else is possible and we can learn from each other. First, you have to realize: I’m in very early stages of this discovery. I have no idea if I’m doing something stupid or missing anything obvious. So be gentle, will ya? I think I see several limitations and quirks: It doesn’t seem possible to have HTML elements in there (to show an image or create a link or something) can be used for styling, but several properties are ignored — like in Chrome/Safari (Firefox was fine) CSS height CSS keyframe animations seem to be a no-go CSS transitions work (if I remember correctly), but try doing something useful with it — I couldn’t — it’s not like you can target specific elements or use pseudo selectors (as far as I know) Using an svg as a background image totally works, but only in Chrome and Safari (as far as I know) Using a base64 image also works Safari wants to repeat the svg background image even if you use no-repeat If you include a text message with your image, you have to “position” it away from the background by using padding (or a newline maybe?) If you include a text message that also has a URL in it, the svg image will be shown right before the URL in addition to the first instance (almost as if it’s pulling in all of your styles again) works! But are there limitations on this? I don’t know yet! I’ve tried a few different ones and they worked! SMIL animation As you are testing the SMIL , you cannot always simply refresh the page to see your changes — sometimes you have to close and reopen the dev tools ([cmd+option+i] for macOS]) animation Here is the very, very messy JS I wrote to achieve the results in the screenshot: The spaces seen after are being used in this case to “fix” the fact that Safari wants to repeat the background when you use . I’m using to help with sizing the area shown, because doesn’t seem to work (even if I use and ). %c padding-left: 100% font-size height display width So what do you think? Is it awesome? Am I crazy? Has this been done before and I’m just behind? Let me know in the comments. :) You can ignore this image — it’s just for the thumbnail. :p Here are some other fun bits: Quicken Loans is hiring right now — we need a lot of different types of people. Or, if I know you in real life, hit me up so I can refer you. And definitely check out . Check out our careers page! Rocket Mortgage Currently playing for Xbox One. Mass Effect: Andromeda Currently listening to by Rotting Christ. Rituals

I made a discovery: SVG and SVG animations in the browser console are possible!

As developers, we spend a lot of our time in the terminal. Most of the developers I talked to use several tools in their console... yes, the console, that itchy thing that will only display letters and numbers. This tool is more powerful than you think. And there are very many nice handy tools to use. This post outlines my list of tools that every developer must have or has heard about ;). So let's get started! Utils - Auto-correct miss-typed commands thefuck is one of those utilities you won't be able to live without once you've tried it. Whenever you mis-type a command and get an error, just run and it'll auto-correct it. Use up/down to choose a correction, or just run to just execute the most likely immediately. thefuck fuck fuck --yeah - Community-maintained docs ) tldr (better man is a huge collection of community-maintained man pages. Unlike traditional man pages, they're summarized, contain useful usage examples and nicely colourized for easy reading tldr - Count lines of code ) scc (better cloc gives you a breakdown of number of lines of code written in each language for a specific directory. It also shows some fun stats, like estimated cost to develop and complexity info. It's incredibly fast, very accurate and has support for a wide range of languages scc - Listing Files ) exa (better ls is a modern Rust-based replacement for the command, for listing files. It can display file-type icons, colors, file/folder info and has several output formats - tree, grid or list exa ls - Disk Usage ) duf (better df is great for showing info about mounted disks and checking free space. It produces a clear and colorful output, and includes options for sorting and customizing results. duf - Download Utility ) aria2 (better wget is a lightweight, multi-protocol, resuming download utility for HTTP/HTTPS, FTP, SFTP, BitTorrent and Metalink, with support for controlling via an RPC interface. It's incredibly , and has tons of . There's also - a nice web interface companion. aria2 feature rich options ziahamza/webui-aria2 - Reading Files ) bat (better cat is a clone of with syntax highlighting and git integration. Written in Rust, it's very performant, and has several options for customizing output and theming. There's support for automatic piping and file concatenation bat cat - File Comparisons ) diff-so-fancy (better diff gives you better looking diffs for comparing strings, files, directories and git changes. The change highlighting makes spotting changes much easier, and you can customize the output layout and colors diff-so-fancy - Watch for changes entr lets you run an arbitrary command whenever file changes. You can pass a file, directory, symlink or regex to specify which files it should watch. It's really useful for automatically rebuilding projects, reacting to logs, automated testing, etc. Unlike similar projects, it uses kqueue(2) or inotify(7) to avoid polling, and improve performance entr - Reading + writing metadata exiftool ExifTool is handy utility for reading, writing, stripping and creating meta information for a wide variety of file types. Never accidentally leak your location when sharing a photo again! - Duplicate file finder fdupes is used for identifying and/or deleting duplicate files within specified directories. It's useful for freeing up disk space when you've got two or more identical files jdupes - Fuzzy file finder ) fzf (better find is an extremely powerful, and easy to use fuzzy file finder and filtering tool. It lets you search for a string or pattern across files. fzf also has available for most shells and IDEs, for showing instant results while searching. This by Alexey Samoshkin highlights some of it's use cases. fzf plugins post - Command benchmarking hyperfine makes it easy to accurately benchmark and compare arbitrary commands or scripts. It takes care of warm-up runs, clearing the cache for accurate results and preventing interference from other programs. It can also export results as raw data and generate charts. hyperfine - Process viewer procs (better ps) is an easy to navigate process viewer, it has colored highlighting, makes sorting and searching for processes easy, has tree view and updates in real-time procs - Search within files ) ripgrep (better grep is a line-oriented search tool that recursively searches the current directory for a regex pattern. It can ignore the contents of and skip binary files. It's able to search within compressed archives, or only search specific extension, and understands files using various encoding methods ripgrep .gitignore - Fast, incremental file transfer rsync lets you copy large files locally or to or from remote hosts or external drives. It can be used to keep files across multiple locations synced, and is perfect for creating, updating and restoring backups rsync - Find and replace ) sd (better sed is an easy, fast and intuitive find and replace tool, based on string literals. It can be executed on a file, an entire directory, or any piped text sd - Directory hierarchy ) tre (better tree outputs a tree stye list of files for your current or a specified directory, with colors. When running with the option, it numbers each item, and creates a temporary alias that you can use to quickly jump to that location tre -e CLI Monitoring and Performance Apps - Bandwidth utilization monitor bandwhich Show bandwidth usage, connection information, outgoing hosts and DNS queries in real-time - Container metrics and monitoring ctop Like , but for monitoring resource usage for running (Docker and runC) containers. It shows real-time CPU, memory and network bandwidth as well as the name, status and ID of each container. There's also a built-in log viewer, and options to manage (stop, start, exec, etc) containers top - Resource monitoring ) bpytop (better htop is a fast, interactive, visual resource monitor. It shows top running processes, recent CPU, mem, disk and network history. From the interface you can navigate, sort and search - there's also support for custom color themes bpytop - Resource monitor + web and API glances is another resource monitor, but with a different feature set. It includes a fully responsive web view, a REST API and historical monitoring. It's easily extendable, and can be integrated with other services glances - Interactive ping tool ) gping (better ping can run ping tests on multiple hosts, while showing results in real-time graph. It can also be used to monitor execution time, when used with the flag gping --cmd - Disk usage analyzer and monitor ) dua-cli (better du let's you interactively view used and available disk space for each mounted drive, and makes freeing up storage easy dua-cli - Command line speed test utility speedtest-cli just runs an internet speed test, via speedtest.net - but straight from the terminal :) speedtest-cli - DNS lookup client ) dog (better dig is an easy-to-use DNS lookup client, with support for DoT and DoH, nicely coloured outputs and the option to emit JSON dog CLI Productivity Apps Surf the web, play music, check emails, manage calendars, read the news and more, all without leaving the terminal! - CLI web browser browsh is a fully interactive, real-time, and modern text-based browser rendered to TTYs and browsers. It supports both mouse and keyboard navigation, and is surprisingly feature rich for a purely terminal based application. It also mitigates battery drain issues that plague modern browsers, and with support for MoSH, you can experience faster load times due to reduced bandwidth browsh - Bookmark manager buku is a terminal-based bookmark manager, with tons of configuration, storage and usage options. There's also an optional and , for accessing your bookmarks outside of the terminal buku web UI browser plugin - Music browser / player cmus is terminal music player, controlled with keyboard shortcuts. It has support for a wide range of audio formats and codecs, and allows organising tracks into playlists and applying playback settings cmus - Track crypto prices cointop show current crypto prices, and track the price history of your portfolio. Supports price alerts, historical charts, currency conversion, fuzzy searching, and much more. You can try the demo via the web at , or by running cointop cointop.sh ssh cointop.sh - Search the web from the terminal ddgr is like , but for DuckDuckGo. It's fast, clean and easy, with support for instant answers, search completion, search bangs, and advanced search. It respects your privacy by default, and also has HTTPS proxy support, and works with Tor ddgr googler - Code editor ) micro (better nano is an easy to use, fast and extendable code editor with mouse support. Since it's packaged into a single binary, installation is as simple as micro curl https://getmic.ro | bash - Calendar client khal is a terminal calendar app, which shows upcoming events, month and agenda views. You can sync it with any CalDAV calendar, and add, edit and remove events directly khal - Email client mutt is a classic, a terminal based mail client for sending, reading and managing emails. It supports all mainstream email protocols and mailbox formats, allows for attachments, BCC/CC, threads, mailing lists and delivery status notifications mut - RSS / ATOM news reader newsboat is an RSS feed reader and aggregator, for reading the news, blogs and following updates directly from the terminal newsboat - Todo + task management taskwarrior is a CLI task management/ todo app. It's both simple and unobtrusive, but also incredibly powerful and scalable, with advanced organisation and query features built in. There's also a lot (700+!) of extra for extending it's functionality and integrating with third-party services task plugins - Terminal UI for Reddit tuir is a great one if you want to look like you're working, while actually browsing Reddit! It's got intuitive keybindings, custom themes, and can render images and multi-media content too. There's also for hacker news tuir haxor CLI Dev Suits - HTTP / API testing testing client httpie is a HTTP client, for testing, debugging and using APIs. It supports everything you'd expect - HTTPS, proxies, authentication, custom headers, persistent sessions, JSON parsing. Usage is simple with an expressive syntax and colourized output. Like other HTTP clients (Postman, Hopscotch, Insomnia, etc) HTTPie also includes a web UI httpie - Full Docker management app lazydocker is a Docker management app, that lets you view all containers and images, manage their state, read logs, check resource usage, restart/ rebuild, analyse layers, prune unused containers, images and volumes, and so much more. It saves you from needing remember, type and chain multiple Docker commands. lazydocker - Full Git management app lazygit is a visual git client, on the command line. Easily add, commit and puch files, resolve conflicts, compare diffs, manage logs, and do complex operations like squashes and rewinds. There's keybindings for everything, colors, and it's easily configurable and extenable lazygit CLI External Sercvices - Reverse proxy for sharing localhost ngrok safely* exposes your localhost to the internet behind a unique URL. This lets you share what you're working on with you're remote colleagues, in real-time. Usage is , but it's also got a lot of advanced features for things like authentication, webhooks, firewalls, traffic inspection, custom/ wildcard domains and much more ngrok very simple - Fast file sharing transfer.sh makes uploading and sharing files really easy, directly from the command line. It's free, supports encryption, gives you a unique URL, and can also be self-hosted.I've written a Bash helper function to make usage a bit easier, you can or try it out by running transfer find it here bash <(curl -L -s https://alicia.url.lol/transfer) - Deploy a site in seconds surge is a free static hosting provider, that you can deploy to directly from the terminal in a single command, just run from within your directory! It supports custom domains, auto SSL certs, pushState support, cross-origin resource support - and it's free! surge surge dist - Check the weather wttr.in is a service that displays the weather in a format that's digestible in the command line. Just run or to try it out. There's URL parameters to customise what data is returned, as well as the format wttr.in curl wttr.in curl wttr.in/London CLI Fun - Have an ASCII cow say your message cowsay is a configurable talking cow. It's based off the by Tony Monroe cowsay original - Output text as big ASCII art text figlet outputs text as ASCII art figlet - Make console output raibow colored lolcat makes any text passed to it rainbow coloured lolcat - Show system data and ditstro info neofetch prints distro and system info (so you can flex that you use Arch btw on r/unixporn) neofetch As an example, I'm using , , and to create a custom time-based MOTD shown to the user when they first log in. It greets them by their name, shows server info and time, date, weather and IP. . cowsay figlet lolcat neofetch Here's the source code Conclusion I think there is at least one interesting tool for you and your productivity enlisted in this list. Hope you enjoy! Also published . here

Unleashing the Power of the Terminal: Essential Tools Every Developer Should Know

In my previous post, I talked about why Console.log() isn’t the most effective debugging tool. In this installment, we will do a bit of an about-face and discuss the ways in which Console.log() is fantastic. Let’s break down some essential concepts and practices that can make your debugging life much easier and more productive. https://youtu.be/Qi7S98HNhYY?embedable=true As a side note, if you like the content of this and the other posts in this series, check out my Debugging book that covers this subject. If you have friends who are learning to code, I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while, check out my Java 8 to 21 book. Understanding Front-End Logging vs. Back-End Logging Front-end logging differs significantly from back-end logging, and understanding this distinction is crucial. Unlike back-end systems, where persistent logs are vital for monitoring and debugging, the fluid nature of front-end development introduces different challenges. When debugging backends, I’d often go for tracepoints which are far superior in that setting. However, the front-end with its constant need to refresh, reload, contexts switch, etc. is a very different beast. In the front end, relying heavily on elaborate logging mechanisms can become cumbersome. While tracepoints remain superior to basic print statements, the continuous testing and browser reloading in front-end workflows lessen their advantage. Moreover, features like logging to a file or structured ingestion are rarely useful in the browser, diminishing the need for a comprehensive logging framework. However, using a logger is still considered best practice over the typical Console.log for long-term logging… For short-term logging, Console.log has some tricks up its sleeve. Leveraging Console Log Levels One of the hidden gems of the browser console is its support for log levels, which is a significant step up from rudimentary print statements. The console provides five levels: • log: Standard logging • debug: Same as log but used for debugging purposes • info: Informative messages, often rendered like log/debug • warn: Warnings that might need attention • error: Errors that have occurred While log and debug can be indistinguishable, these levels allow for a more organized and filtered debugging experience. Browsers enable filtering the output based on these levels, mirroring the capabilities of server-side logging systems and allowing you to focus on relevant messages. Customizing Console Output With CSS Front-end development allows for creative solutions, and logging is no exception. Using CSS styles in the console can make logs more visually distinct. By utilizing %c in a console message, you can apply custom CSS: console.customLog = function(msg) {
    console.log("%c" + msg,"color:black;background:pink;font-family:system-ui;font-size:4rem;-webkit-text-stroke: 1px black;font-weight:bold")
}
console.customLog("Dazzle") This approach is helpful when you need to make specific logs stand out or organize output visually. You can use multiple %c substitutions to apply various styles to different parts of a log message. Stack Tracing With console.trace() The console.trace() method can print a stack trace at a particular location, which can sometimes be helpful for understanding the flow of your code. However, due to JavaScript’s asynchronous behavior, stack traces aren’t always as straightforward as in back-end debugging. Still, in specific scenarios, such as synchronous code segments or event handling, it can be quite valuable. Assertions for Design-by-Contract Assertions in front-end code allow developers to enforce expectations and promote a “fail-fast” mentality. Using Console.assert(), you can test conditions: console.assert(x > 0, 'x must be greater than zero'); In the browser, a failed assertion appears as an error, similar to a console.error. An added benefit is that assertions can be stripped from production builds, removing any performance impact. This makes assertions a great tool for enforcing design contracts during development without compromising production efficiency. Copying Objects to the Clipboard Debugging often involves inspecting objects, and the copy(object) method allows you to copy an object’s content to the clipboard for external use. This feature is useful when you need to transfer data or analyze it outside the browser. Inspecting With console.dir() and dirxml() The console.dir() method provides a more detailed view of objects, showing their properties as you’d see in a debugger. This is particularly helpful for inspecting DOM elements or exploring API responses. Meanwhile, console.dirxml() allows you to view objects as XML, which can be useful when debugging HTML structures. Counting Function Calls Keeping track of how often a function is called or a code block is executed can be crucial. The console.count() method tracks the number of times it’s invoked, helping you verify that functions are called as expected: function myFunction() {
    console.count('myFunction called');
} You can reset the counter using console.countReset(). This simple tool can help you catch performance issues or confirm the correct execution flow. Organizing Logs With Groups To prevent log clutter, use console groups to organize related messages. console.group() starts a collapsible log section, and console.groupEnd() closes it: console.group('My Group');
console.log('Message 1');
console.log('Message 2');
console.groupEnd(); Grouping makes it easier to navigate complex logs and keeps your console clean. Chrome-Specific Debugging Features Monitoring Functions: Chrome’s monitor() method logs every call to a function, showing the arguments and enabling a method-tracing experience. Monitoring Events: Using monitorEvents(), you can log events on an element. This is useful for debugging UI interactions. For example, monitorEvents(window, 'mouseout') logs only mouseout events. Querying Object Instances: queryObjects(Constructor) lists all objects created with a specific constructor, giving you insights into memory usage and object instantiation. Final Word Front-end debugging tools have come a long way. These tools provide a rich set of features that go far beyond simple console.log() statements. From log levels and CSS styling to assertions and event monitoring, mastering these techniques can transform your debugging workflow. If you read this post as part of my series, you will notice a big change in my attitude toward debugging when we reached the front end. Front-end debugging is very different when compared to back-end debugging. When debugging the backend, I’m vehemently against code changes for debugging (e.g. println debugging), but on the front end, this can be a reasonable hack. The change in environment justifies it. The short lifecycle, the single-user use case, and the risk is smaller. While there are many transferrable skills we pick up while debugging, it’s important to remain flexible in our attitude. Next time, we will discuss networking and storage debugging on the front end. In my previous post, I talked about why Console.log() isn’t the most effective debugging tool. In this installment, we will do a bit of an about-face and discuss the ways in which Console.log() is fantastic. Let’s break down some essential concepts and practices that can make your debugging life much easier and more productive. Console.log() Console.log() https://youtu.be/Qi7S98HNhYY?embedable=true https://youtu.be/Qi7S98HNhYY?embedable=true As a side note, if you like the content of this and the other posts in this series, check out my Debugging book that covers t his subject. If you have friends who are learning to code, I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while, check out my Java 8 to 21 book . Debugging book t Java Basics book. Java 8 to 21 book . Understanding Front-End Logging vs. Back-End Logging Understanding Front-End Logging vs. Back-End Logging Front-end logging differs significantly from back-end logging, and understanding this distinction is crucial. Unlike back-end systems, where persistent logs are vital for monitoring and debugging, the fluid nature of front-end development introduces different challenges. When debugging backends, I’d often go for tracepoints which are far superior in that setting. However, the front-end with its constant need to refresh, reload, contexts switch, etc. is a very different beast. In the front end, relying heavily on elaborate logging mechanisms can become cumbersome. While tracepoints remain superior to basic print statements, the continuous testing and browser reloading in front-end workflows lessen their advantage. Moreover, features like logging to a file or structured ingestion are rarely useful in the browser, diminishing the need for a comprehensive logging framework. However, using a logger is still considered best practice over the typical Console.log for long-term logging… For short-term logging, Console.log has some tricks up its sleeve. Console.log Console.log Leveraging Console Log Levels Leveraging Console Log Levels One of the hidden gems of the browser console is its support for log levels, which is a significant step up from rudimentary print statements. The console provides five levels: • log : Standard logging log • debug : Same as log but used for debugging purposes debug • info : Informative messages, often rendered like log/debug info • warn : Warnings that might need attention warn • error : Errors that have occurred error While log and debug can be indistinguishable, these levels allow for a more organized and filtered debugging experience. Browsers enable filtering the output based on these levels, mirroring the capabilities of server-side logging systems and allowing you to focus on relevant messages. Customizing Console Output With CSS Customizing Console Output With CSS Front-end development allows for creative solutions, and logging is no exception. Using CSS styles in the console can make logs more visually distinct. By utilizing %c in a console message, you can apply custom CSS: %c console.customLog = function(msg) {
    console.log("%c" + msg,"color:black;background:pink;font-family:system-ui;font-size:4rem;-webkit-text-stroke: 1px black;font-weight:bold")
}
console.customLog("Dazzle") console.customLog = function(msg) {
    console.log("%c" + msg,"color:black;background:pink;font-family:system-ui;font-size:4rem;-webkit-text-stroke: 1px black;font-weight:bold")
}
console.customLog("Dazzle") This approach is helpful when you need to make specific logs stand out or organize output visually. You can use multiple %c substitutions to apply various styles to different parts of a log message. %c Stack Tracing With console.trace() Stack Tracing With console.trace() The console.trace() method can print a stack trace at a particular location, which can sometimes be helpful for understanding the flow of your code. However, due to JavaScript’s asynchronous behavior, stack traces aren’t always as straightforward as in back-end debugging. Still, in specific scenarios, such as synchronous code segments or event handling, it can be quite valuable. console.trace() Assertions for Design-by-Contract Assertions for Design-by-Contract Assertions in front-end code allow developers to enforce expectations and promote a “fail-fast” mentality. Using Console.assert() , you can test conditions: Console.assert() console.assert(x > 0, 'x must be greater than zero'); console.assert(x > 0, 'x must be greater than zero'); In the browser, a failed assertion appears as an error, similar to a console.error. An added benefit is that assertions can be stripped from production builds, removing any performance impact. This makes assertions a great tool for enforcing design contracts during development without compromising production efficiency. Copying Objects to the Clipboard Copying Objects to the Clipboard Debugging often involves inspecting objects, and the copy(object) method allows you to copy an object’s content to the clipboard for external use. This feature is useful when you need to transfer data or analyze it outside the browser. copy(object) Inspecting With console.dir() and dirxml() Inspecting With console.dir() and dirxml() The console.dir() method provides a more detailed view of objects, showing their properties as you’d see in a debugger. This is particularly helpful for inspecting DOM elements or exploring API responses. Meanwhile, console.dirxml() allows you to view objects as XML, which can be useful when debugging HTML structures. console.dir() console.dirxml() Counting Function Calls Counting Function Calls Keeping track of how often a function is called or a code block is executed can be crucial. The console.count() method tracks the number of times it’s invoked, helping you verify that functions are called as expected: console.count() function myFunction() {
    console.count('myFunction called');
} function myFunction() {
    console.count('myFunction called');
} You can reset the counter using console.countReset() . This simple tool can help you catch performance issues or confirm the correct execution flow. console.countReset() Organizing Logs With Groups Organizing Logs With Groups To prevent log clutter, use console groups to organize related messages. console.group() starts a collapsible log section, and console.groupEnd() closes it: console.group() console.groupEnd() console.group('My Group');
console.log('Message 1');
console.log('Message 2');
console.groupEnd(); console.group('My Group');
console.log('Message 1');
console.log('Message 2');
console.groupEnd(); Grouping makes it easier to navigate complex logs and keeps your console clean. Chrome-Specific Debugging Features Chrome-Specific Debugging Features Monitoring Functions : Chrome’s monitor() method logs every call to a function, showing the arguments and enabling a method-tracing experience. Monitoring Functions monitor() Monitoring Events : Using monitorEvents() , you can log events on an element. This is useful for debugging UI interactions. For example, monitorEvents(window, 'mouseout') logs only mouseout events. Monitoring Events monitorEvents() monitorEvents(window, 'mouseout') mouseout Querying Object Instances : queryObjects(Constructor) lists all objects created with a specific constructor, giving you insights into memory usage and object instantiation. Querying Object Instances queryObjects(Constructor) Final Word Final Word Front-end debugging tools have come a long way. These tools provide a rich set of features that go far beyond simple console.log() statements. From log levels and CSS styling to assertions and event monitoring, mastering these techniques can transform your debugging workflow. console.log() If you read this post as part of my series, you will notice a big change in my attitude toward debugging when we reached the front end. Front-end debugging is very different when compared to back-end debugging. When debugging the backend, I’m vehemently against code changes for debugging (e.g. println debugging), but on the front end, this can be a reasonable hack. The change in environment justifies it. The short lifecycle, the single-user use case, and the risk is smaller. While there are many transferrable skills we pick up while debugging, it’s important to remain flexible in our attitude. Next time, we will discuss networking and storage debugging on the front end.

Front-End Debugging Part 2: Console.log() to the Max Explained

As a Java developer, most of my focus is on the backend side of debugging. Front-end debugging poses different challenges and has sophisticated tools of its own. Unfortunately, print-based debugging has become the norm in front-end. To be fair, it makes more sense there as the cycles are different and the problem is always a single-user problem. But even if you choose to use Console.log, there’s a lot of nuance to pick up there. The links in this article include affiliate links to Amazon. You won’t be charged anything extra for clicking on these links, but you will be supporting me if you do choose to purchase something through one of these links. Thanks! https://youtu.be/1KFlbecOmc0?embedable=true As a side note, if you like the content of this and the other posts in this series check out my Debugging book that covers this subject. If you have friends that are learning to code I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while check out my Java 8 to 21 book. Instant Debugging with the debugger Keyword A cool yet powerful tool in JavaScript is the debugger keyword. Instead of simply printing a stack trace, we can use this keyword to launch the debugger directly at the line of interest. That is a fantastic tool that instantly brings your attention to a bug, I often use it in my debug builds of the front-end instead of just printing an error log. How to Use It: Place the debugger keyword within your code, particularly within error-handling methods. When the code execution hits this line, it automatically pauses, allowing you to inspect the current state, step through code, and understand what's going wrong. Notice that while this is incredibly useful during development, we must remember to remove or conditionally exclude debugger statements in production environments. A release build should not include these calls in a production site live environment. Triggering Debugging from the Console Modern browsers allow you to invoke debugging directly from the console, adding an additional layer of flexibility to your debugging process. Example: By using the debug(functionName) command in the console, you can set a breakpoint at the start of the specified function. When this function is subsequently invoked, the execution halts, sending you directly into the debugger. function hello(name) {
    Console.log("Hello " + name)
}
debug(hello)
hello("Shai") This is particularly useful when you want to start debugging without modifying the source code, or when you need to inspect a function that’s only defined in the global scope. DOM Breakpoints: Monitoring DOM Changes DOM breakpoints are an advanced feature in Chrome and Firebug (Firefox plugin) that allows you to pause execution when a specific part of the DOM is altered. To use it we can right-click on the desired DOM element, select “Break On,” and choose the specific mutation type you are interested in (e.g., subtree modifications, attribute changes, etc.). DOM breakpoints are extremely powerful for tracking down issues where DOM manipulation causes unexpected results, such as dynamic content loading or changes in the user interface that disrupt the intended layout or functionality. Think of them like field breakpoints we discussed in the past. These breakpoints complement traditional line and conditional breakpoints, providing a more granular approach to debugging complex front-end issues. This is a great tool to use when the DOM is manipulated by an external dependency. XHR Breakpoints: Uncovering Hidden Network Calls Understanding who initiates specific network requests can be challenging, especially in large applications with multiple sources contributing to a request. XHR (XMLHttpRequest) breakpoints provide a solution to this problem. In Chrome or Firebug, set an XHR breakpoint by specifying a substring of the URI you wish to monitor. When a request matching this pattern is made, the execution stops, allowing you to investigate the source of the request. This tool is invaluable when dealing with dynamically generated URIs or complex flows where tracking the origin of a request is not straightforward. Notice that you should be selective with the filters you set; leaving the filter blank will cause the breakpoint to trigger on all XHR requests, which can become overwhelming. Simulating Environments for Debugging Sometimes, the issues you need to debug are specific to certain environments, such as mobile devices or different geographical locations. Chrome and Firefox offer several simulation tools to help you replicate these conditions on your desktop. Simulating User Agents: Change the browser’s user agent to mimic different devices or operating systems. This can help you identify platform-specific issues or debug server-side content delivery that varies by user agent.


Geolocation Spoofing: Modify the browser’s reported location to test locale-specific features or issues. This is particularly useful for applications that deliver region-specific content or services.


Touch and Device Orientation Emulation: Simulate touch events or change the device orientation to see how your application responds to mobile-specific interactions. This is crucial for ensuring a seamless user experience across all devices. These are things that are normally very difficult to reproduce. E.g. touch related issues are often challenging to debug on the device. By simulating them on the desktop browser we can shorten the debug cycle and use the tooling available on the desktop. Debugging Layout and Style Issues CSS and HTML bugs can be particularly tricky, often requiring a detailed examination of how elements are rendered and styled. Inspect Element: The "inspect element" tool is the cornerstone of front-end debugging, allowing you to view and manipulate the DOM and CSS in real-time. As you make changes, the page updates instantly, providing immediate feedback on your tweaks.


Addressing Specificity Issues: One common problem is CSS specificity, where a more specific selector overrides the styles you intend to apply. The inspect element view highlights overridden styles, helping you identify and resolve conflicts.


Firefox vs. Chrome: While both browsers offer robust tools, they have different approaches to organizing these features. Firefox’s interface may seem more straightforward, with fewer tabs, while Chrome organizes similar tools under various tabs, which can either streamline your workflow or add complexity, depending on your preference. Final Word There are many front-end tools that I want to discuss in the coming posts. I hope you picked up a couple of new debugging tricks in this first part. Front-end debugging requires a deep understanding of browser tools and JavaScript capabilities. By mastering the techniques outlined in this post—instant debugging with the debugger keyword, DOM and XHR breakpoints, environment simulation, and layout inspection—you can significantly enhance your debugging efficiency and deliver more robust, error-free web applications. As a Java developer, most of my focus is on the backend side of debugging. Front-end debugging poses different challenges and has sophisticated tools of its own. Unfortunately, print-based debugging has become the norm in front-end. To be fair, it makes more sense there as the cycles are different and the problem is always a single-user problem. But even if you choose to use Console.log , there’s a lot of nuance to pick up there. Console.log The links in this article include affiliate links to Amazon. You won’t be charged anything extra for clicking on these links, but you will be supporting me if you do choose to purchase something through one of these links. Thanks! The links in this article include affiliate links to Amazon. You won’t be charged anything extra for clicking on these links, but you will be supporting me if you do choose to purchase something through one of these links. Thanks! https://youtu.be/1KFlbecOmc0?embedable=true https://youtu.be/1KFlbecOmc0?embedable=true As a side note, if you like the content of this and the other posts in this series check out my Debugging book that covers this subject. If you have friends that are learning to code I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while check out my Java 8 to 21 book. As a side note, if you like the content of this and the other posts in this series check out my Debugging book that covers t his subject. If you have friends that are learning to code I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while check out my Java 8 to 21 book . Debugging book t Java Basics book. Java 8 to 21 book . Instant Debugging with the debugger Keyword Instant Debugging with the debugger A cool yet powerful tool in JavaScript is the debugger keyword. Instead of simply printing a stack trace, we can use this keyword to launch the debugger directly at the line of interest. That is a fantastic tool that instantly brings your attention to a bug, I often use it in my debug builds of the front-end instead of just printing an error log. debugger How to Use It: Place the debugger keyword within your code, particularly within error-handling methods. When the code execution hits this line, it automatically pauses, allowing you to inspect the current state, step through code, and understand what's going wrong. How to Use It: debugger Notice that while this is incredibly useful during development, we must remember to remove or conditionally exclude debugger statements in production environments. A release build should not include these calls in a production site live environment. debugger Triggering Debugging from the Console Triggering Debugging from the Console Modern browsers allow you to invoke debugging directly from the console, adding an additional layer of flexibility to your debugging process. Example: By using the debug(functionName) command in the console, you can set a breakpoint at the start of the specified function. When this function is subsequently invoked, the execution halts, sending you directly into the debugger. Example: debug(functionName) function hello(name) {
    Console.log("Hello " + name)
}
debug(hello)
hello("Shai") function hello(name) {
    Console.log("Hello " + name)
}
debug(hello)
hello("Shai") This is particularly useful when you want to start debugging without modifying the source code, or when you need to inspect a function that’s only defined in the global scope. DOM Breakpoints: Monitoring DOM Changes DOM Breakpoints: Monitoring DOM Changes DOM breakpoints are an advanced feature in Chrome and Firebug (Firefox plugin) that allows you to pause execution when a specific part of the DOM is altered. To use it we can right-click on the desired DOM element, select “Break On,” and choose the specific mutation type you are interested in (e.g., subtree modifications, attribute changes, etc.). DOM breakpoints are extremely powerful for tracking down issues where DOM manipulation causes unexpected results, such as dynamic content loading or changes in the user interface that disrupt the intended layout or functionality. Think of them like field breakpoints we discussed in the past. These breakpoints complement traditional line and conditional breakpoints, providing a more granular approach to debugging complex front-end issues. This is a great tool to use when the DOM is manipulated by an external dependency. XHR Breakpoints: Uncovering Hidden Network Calls XHR Breakpoints: Uncovering Hidden Network Calls Understanding who initiates specific network requests can be challenging, especially in large applications with multiple sources contributing to a request. XHR ( XMLHttpRequest ) breakpoints provide a solution to this problem. XMLHttpRequest In Chrome or Firebug, set an XHR breakpoint by specifying a substring of the URI you wish to monitor. When a request matching this pattern is made, the execution stops, allowing you to investigate the source of the request. This tool is invaluable when dealing with dynamically generated URIs or complex flows where tracking the origin of a request is not straightforward. Notice that you should be selective with the filters you set; leaving the filter blank will cause the breakpoint to trigger on all XHR requests, which can become overwhelming. Simulating Environments for Debugging Simulating Environments for Debugging Sometimes, the issues you need to debug are specific to certain environments, such as mobile devices or different geographical locations. Chrome and Firefox offer several simulation tools to help you replicate these conditions on your desktop. Simulating User Agents: Change the browser’s user agent to mimic different devices or operating systems. This can help you identify platform-specific issues or debug server-side content delivery that varies by user agent. Geolocation Spoofing: Modify the browser’s reported location to test locale-specific features or issues. This is particularly useful for applications that deliver region-specific content or services. Touch and Device Orientation Emulation: Simulate touch events or change the device orientation to see how your application responds to mobile-specific interactions. This is crucial for ensuring a seamless user experience across all devices. Simulating User Agents: Change the browser’s user agent to mimic different devices or operating systems. This can help you identify platform-specific issues or debug server-side content delivery that varies by user agent. Simulating User Agents: Change the browser’s user agent to mimic different devices or operating systems. This can help you identify platform-specific issues or debug server-side content delivery that varies by user agent. Simulating User Agents: Geolocation Spoofing: Modify the browser’s reported location to test locale-specific features or issues. This is particularly useful for applications that deliver region-specific content or services. Geolocation Spoofing: Modify the browser’s reported location to test locale-specific features or issues. This is particularly useful for applications that deliver region-specific content or services. Geolocation Spoofing: Touch and Device Orientation Emulation: Simulate touch events or change the device orientation to see how your application responds to mobile-specific interactions. This is crucial for ensuring a seamless user experience across all devices. Touch and Device Orientation Emulation: Simulate touch events or change the device orientation to see how your application responds to mobile-specific interactions. This is crucial for ensuring a seamless user experience across all devices. Touch and Device Orientation Emulation: These are things that are normally very difficult to reproduce. E.g. touch related issues are often challenging to debug on the device. By simulating them on the desktop browser we can shorten the debug cycle and use the tooling available on the desktop. Debugging Layout and Style Issues Debugging Layout and Style Issues CSS and HTML bugs can be particularly tricky, often requiring a detailed examination of how elements are rendered and styled. Inspect Element: The "inspect element" tool is the cornerstone of front-end debugging, allowing you to view and manipulate the DOM and CSS in real-time. As you make changes, the page updates instantly, providing immediate feedback on your tweaks. Addressing Specificity Issues: One common problem is CSS specificity, where a more specific selector overrides the styles you intend to apply. The inspect element view highlights overridden styles, helping you identify and resolve conflicts. Firefox vs. Chrome: While both browsers offer robust tools, they have different approaches to organizing these features. Firefox’s interface may seem more straightforward, with fewer tabs, while Chrome organizes similar tools under various tabs, which can either streamline your workflow or add complexity, depending on your preference. Inspect Element: The "inspect element" tool is the cornerstone of front-end debugging, allowing you to view and manipulate the DOM and CSS in real-time. As you make changes, the page updates instantly, providing immediate feedback on your tweaks. Inspect Element: The "inspect element" tool is the cornerstone of front-end debugging, allowing you to view and manipulate the DOM and CSS in real-time. As you make changes, the page updates instantly, providing immediate feedback on your tweaks. Inspect Element: Addressing Specificity Issues: One common problem is CSS specificity, where a more specific selector overrides the styles you intend to apply. The inspect element view highlights overridden styles, helping you identify and resolve conflicts. Addressing Specificity Issues: One common problem is CSS specificity, where a more specific selector overrides the styles you intend to apply. The inspect element view highlights overridden styles, helping you identify and resolve conflicts. Addressing Specificity Issues: Firefox vs. Chrome: While both browsers offer robust tools, they have different approaches to organizing these features. Firefox’s interface may seem more straightforward, with fewer tabs, while Chrome organizes similar tools under various tabs, which can either streamline your workflow or add complexity, depending on your preference. Firefox vs. Chrome: While both browsers offer robust tools, they have different approaches to organizing these features. Firefox’s interface may seem more straightforward, with fewer tabs, while Chrome organizes similar tools under various tabs, which can either streamline your workflow or add complexity, depending on your preference. Firefox vs. Chrome: Final Word There are many front-end tools that I want to discuss in the coming posts. I hope you picked up a couple of new debugging tricks in this first part. Front-end debugging requires a deep understanding of browser tools and JavaScript capabilities. By mastering the techniques outlined in this post—instant debugging with the debugger keyword, DOM and XHR breakpoints, environment simulation, and layout inspection—you can significantly enhance your debugging efficiency and deliver more robust, error-free web applications. debugger

Mastering Front End Debugging—Part 1: From Console Logs to Advanced Techniques 

What is a console, anyway? Most would say it’s a platform that publishes games and unites gamer communities. Well, by that definition, gaming sidechains like Ronin are digital consoles, sharing plenty in common with hardware cousins like Xbox. Think about it: both count premier gaming titles, curate centralized ecosystems and wield distribution and decision-making power. But, web3 gaming platforms go one step further to offer much-needed stickiness in asset ownership, personalized identities, and vibrant community economies. This is an emerging gaming sector that moves fast and breaks things. But, right now, these “consoles” are sparking a renaissance in how games are published, played, and sustained. The blockchain is the console As publisher and platform, Ronin shares more in common with a traditional gaming console than you might think. For example, Microsoft and Sky Mavis operate their respective “console” as centralized gaming ecosystems, orchestrating communities and economies around their protocols/platforms. Even their onboarding methods are similar. Ronin, the private gaming sidechain, is driven by flagship games that introduce players to the ecosystem. Axie Infinity served this first-party role for the network—attracting early users and developers just as Halo (made by Microsoft-owned Bungie) did for Xbox and Counter-Strike: Global Offensive (made by Valve) did for Steam. This model of launching premiere first-party titles fuels network effects by inviting and incentivizing more peripheral games and participants to join the growing ecosystem. Then, the community can thrive. Gaming needs web3’s stickiness Community is a big part of why console fanboys exist. The games matter, of course, but users often find their home by interacting with others. Something like Xbox LIVE makes this possible with universal usernames and profile stats. In turn, “you” can better express yourself. Web3 and gaming leaders like Immutable, Avalanche, and CARV take this connective tissue of community to a whole new level. For example, NFT standards like ERC-7231 link multiple gamertags to one profile—creating an “identity of identities” that helps players tell their story throughout the metaverse. Moreover, these blockchain-based protocols provide an unprecedented level of data control by allowing players to fully own and encrypt their information directly onchain. Gaming chains excel at building the ecosystem—the ultimate aspiration of consoles. They enable the seamless transfer of assets between games, nurture user loyalty, and foster distinct communities. The synergy and interconnectedness of these blockchain gaming environments surpass anything we’ve seen in conventional gaming, laying the groundwork for experiences that are not just more immersive but also more player-centric. The appeal is simple on both sides of the industry equation: web3 gamers enjoy real stakes in player-driven markets and gamemakers tap into new value streams. A lifeline for an industry at a crossroads These are big pluses for a gaming industry at a crossroads. Mobile game revenue, which constitutes nearly 50% of the global gaming market, is down for the second consecutive year. Meanwhile, as I recently wrote, user acquisition costs head in the other direction. Understandably, gaming wants to harness web3’s demographics (users with stronger spending power, high project loyalty, and experience with complex games) and conversion capabilities (improved ability to guide users through in-depth, in-game conversions with incentives and token expectations) in shaping tomorrow. Additionally, gaming must be eyeing these new revenue streams with envy. Most recently, for example, Telegram showed that even platforms can become consoles via blockchain integration. As one of the world’s biggest chat platforms with almost 1B users, Telegram officially endorsed TON as the app’s “official web3 infrastructure”. Mini-apps inside the platform boomed with play-to-earn games leveraging TON to engage and reward players. The successes speak for themselves – Notcoin is worth more than $1B, Hamster Kombat is one of the fastest-growing web3 apps and BANANA hit 10M users in just over a month. This integration between protocol and platform once again shows the power of uniting major user bases with incentive-aligned games – and who’s to say what’s the limit or where this goes next? Digital consoles and their various iterations promise to define the gaming landscape, ushering in an era where data, ownership, and community are at the core of every experience. Watch this space. What is a console, anyway? Most would say it’s a platform that publishes games and unites gamer communities. Well, by that definition, gaming sidechains like Ronin are digital consoles, sharing plenty in common with hardware cousins like Xbox. Think about it: both count premier gaming titles, curate centralized ecosystems and wield distribution and decision-making power. But, web3 gaming platforms go one step further to offer much-needed stickiness in asset ownership, personalized identities, and vibrant community economies. This is an emerging gaming sector that moves fast and breaks things. But, right now, these “consoles” are sparking a renaissance in how games are published, played, and sustained. The blockchain is the console As publisher and platform, Ronin shares more in common with a traditional gaming console than you might think. For example, Microsoft and Sky Mavis operate their respective “console” as centralized gaming ecosystems, orchestrating communities and economies around their protocols/platforms. Even their onboarding methods are similar. Ronin, the private gaming sidechain, is driven by flagship games that introduce players to the ecosystem. Axie Infinity served this first-party role for the network—attracting early users and developers just as Halo (made by Microsoft-owned Bungie) did for Xbox and Counter-Strike: Global Offensive (made by Valve) did for Steam. This model of launching premiere first-party titles fuels network effects by inviting and incentivizing more peripheral games and participants to join the growing ecosystem. Then, the community can thrive. Gaming needs web3’s stickiness Community is a big part of why console fanboys exist. The games matter, of course, but users often find their home by interacting with others. Something like Xbox LIVE makes this possible with universal usernames and profile stats. In turn, “you” can better express yourself. Web3 and gaming leaders like Immutable, Avalanche, and CARV take this connective tissue of community to a whole new level. For example, NFT standards like ERC-7231 link multiple gamertags to one profile—creating an “identity of identities” that helps players tell their story throughout the metaverse. Moreover, these blockchain-based protocols provide an unprecedented level of data control by allowing players to fully own and encrypt their information directly onchain. NFT standards like ERC-7231 NFT standards like ERC-7231 Gaming chains excel at building the ecosystem—the ultimate aspiration of consoles. They enable the seamless transfer of assets between games, nurture user loyalty, and foster distinct communities. The synergy and interconnectedness of these blockchain gaming environments surpass anything we’ve seen in conventional gaming, laying the groundwork for experiences that are not just more immersive but also more player-centric. The appeal is simple on both sides of the industry equation: web3 gamers enjoy real stakes in player-driven markets and gamemakers tap into new value streams. A lifeline for an industry at a crossroads These are big pluses for a gaming industry at a crossroads. Mobile game revenue, which constitutes nearly 50% of the global gaming market, is down for the second consecutive year . Meanwhile, as I recently wrote , user acquisition costs head in the other direction. for the second consecutive year for the second consecutive year as I recently wrote as I recently wrote Understandably, gaming wants to harness web3’s demographics (users with stronger spending power, high project loyalty, and experience with complex games) and conversion capabilities (improved ability to guide users through in-depth, in-game conversions with incentives and token expectations) in shaping tomorrow. Additionally, gaming must be eyeing these new revenue streams with envy. Most recently, for example, Telegram showed that even platforms can become consoles via blockchain integration. As one of the world’s biggest chat platforms with almost 1B users, Telegram officially endorsed TON as the app’s “ official web3 infrastructure ”. Mini-apps inside the platform boomed with play-to-earn games leveraging TON to engage and reward players. The successes speak for themselves – Notcoin is worth more than $1B , Hamster Kombat is one of the fastest-growing web3 apps and BANANA hit 10M users in just over a month . official web3 infrastructure official web3 infrastructure Notcoin is worth more than $1B Notcoin is worth more than $1B Hamster Kombat is one of the fastest-growing web3 apps Hamster Kombat is one of the fastest-growing web3 apps BANANA hit 10M users in just over a month BANANA hit 10M users in just over a month This integration between protocol and platform once again shows the power of uniting major user bases with incentive-aligned games – and who’s to say what’s the limit or where this goes next? Digital consoles and their various iterations promise to define the gaming landscape, ushering in an era where data, ownership, and community are at the core of every experience. Watch this space.

Stories, News & Mentions about CONSOLE

Console’s Stories on HackerNoon

Console's News & Mentions