标签：#management

The Ubiquitous Infinite Scroll Pagination Bug Almost every Flutter engineer has encountered the dreaded infinite scroll race condition in production. The user opens a list, flings their thumb down the screen on a spotty cellular connection, and triggers multiple scroll notifications past the bottom threshold within milliseconds. Before the first asynchronous HTTP network request finishes, the scroll listener fires again. Suddenly, your list duplicates items, page counters jump ahead, or the state machine locks up entirely. Recently, mobile developer Ali Wajdan published a widely discussed article titled 3 Lines of Dart async* Code That Fixed My Infinite Scroll Pagination . In his article, Ali accurately diagnoses the root cause of standard pagination headaches: "Most Flutter pagination code I have seen, including my own for years, wraps a mutable state object around a scroll listener. A page counter, a loading boolean, a hasMore flag, and a fetch method the UI calls when it hits the scroll threshold. It works until two scroll events fire close together, or a rebuild triggers a second load before the first future resolves... It is a classic race condition, and it gets worse once the state lives across a page counter, a hasMore flag, and a loading flag that all need to stay in sync." To escape this trap, Ali suggested encapsulating pagination logic inside a Dart async* generator and consuming it with a StreamIterator : // The pattern proposed in Ali Wajdan's article Stream < List < Post >> fetchPostsPaginated ( String query ) async * { var page = 0 ; var hasMore = true ; while ( hasMore ) { final batch = await api . fetchPosts ( query , page: page ); hasMore = batch . isNotEmpty ; page ++ ; yield batch ; } } final iterator = StreamIterator ( fetchPostsPaginated ( query )); Future < List < Post >> loadNextPage () async { if ( ! await iterator . moveNext ()) return const []; return iterator . current ; } On the surface, moving mutable state into local generator variable

Most EM interview prep fails the same way. You pick three strong stories, polish them until they're tight, run them past a friend, and walk in confident. Then somebody asks how you'd handle a high performer who's difficult to work with, and none of your three stories touch it. That isn't a depth problem. It's a coverage problem, and it's the thing that makes the EM loop different from every IC loop you've done. An IC loop samples from a narrow surface. Systems, code, a couple of behavioural questions that mostly serve as tiebreakers. You can prepare for it by going deep on a small number of technical narratives. An EM loop samples from a wide one. Nine areas, roughly, and you can be excellent at seven of them and still lose the loop on the two you never thought about. The nine areas Team building and hiring Performance management and difficult conversations Conflict and difficult relationships Delivery, prioritization and ambiguity Cross-functional partnership Growth, coaching and career development Technical judgment and architecture Values, culture and self-awareness Vision and scaling Look at that list and be honest about which two are thin for you. For most people coming from a senior IC role it's 2 and 3, because those are the parts of the job you've watched from the outside rather than done. What the questions are actually checking Underneath the surface wording, almost every behavioural question in an EM loop is checking one of four things. Did you run a real process, or improvise? "I had a conversation with them" is an improvisation. "I named the specific pattern with dates, we agreed a 30-day plan, I checked in weekly" is a process. Can you name a specific tradeoff you made, and why? Not that tradeoffs existed. Which one you picked, what it cost, and what you got. Do you own outcomes without deflecting or over-apologizing? Both failure modes read badly. Blaming the org is worse, but flagellating yourself for four minutes over a bad hire is not much better.

Security teams have historically operated on instinct. A firewall rule feels right. A new tool seems like it will help. An audit finding gets patched because someone said it was important. That approach worked when security was a small, contained function bolted onto IT. It doesn't work anymore. Attack surfaces are larger, budgets are scrutinized more closely, and boards want to know whether the money spent on security is actually reducing risk. The answer to that pressure is metrics-driven security: running your security program the way a good engineering or product team runs theirs, with defined measurements, targets, and feedback loops. Table of Contents What "Metrics-Driven" Actually Means Why Most Security Metrics Fail Metrics Worth Tracking Turning Metrics Into Decisions The Cultural Shift Conclusion What Metrics-Driven Actually Means Being metrics-driven means three specific things: You decide in advance what "good" looks like. Before you deploy a new control, you define what success would look like in numbers, not just vibes. You track the same metrics over time, so you can tell whether things are improving, stagnant, or getting worse. You let the metrics change what you do. If a number tells you a program isn't working, you adjust the program. If it tells you a risk is shrinking, you can safely redirect resources elsewhere. The distinguishing feature isn't the existence of data. It's that decisions actually flow from the data, rather than data being collected to justify decisions already made. Why Most Security Metrics Fail A lot of security metrics programs collapse under their own weight because they measure activity instead of outcomes. Counting the number of vulnerabilities scanned, phishing emails sent, or tickets closed tells you that people were busy. It doesn't tell you whether the organization is safer. Good metrics programs avoid a few common traps: Vanity metrics. Numbers that always trend in a favourable direction regardless of actual security p

Disclosure: I work on Tessera, which is one of the tools in the gap I am describing. Ask a fifty-person engineering organisation how they control production access and you will hear the same answer with small variations: a bastion host, SSH keys distributed by configuration management, a shared kubeconfig somewhere, and a spreadsheet or a Notion page that is out of date. Nobody chose that. It is what remains after the alternatives were priced. How the category got shaped Privileged access management grew up serving banks, telcos and governments in the 2000s. Those buyers had specific characteristics: thousands of administrators, regulators with written opinions, dedicated security teams, and procurement processes measured in quarters. Products shaped themselves accordingly. Six-figure entry prices. Deployments measured in months with professional services attached. Feature sets covering every mainframe and network appliance in a bank's estate. Sales motions that start with a discovery call and a mutual NDA. That was a reasonable fit for those buyers. It is a terrible fit for a company with sixty engineers, no dedicated security team, one person who is security-adjacent, and a procurement process that consists of a founder approving a card payment. So the mid-market did what people do when a category prices them out: they built the minimum themselves. A bastion is a bastion because it was free and it was Tuesday. The problem this leaves The bastion answer works, up to a point, and it is worth being specific about where the point is. A bastion controls the door. It does not control the room. Once someone is through, there is no per-command record, no way to reduce their privileges while they are working, and no session replay. And keys still have to be distributed and revoked behind it, which means the original problem is intact — it just has a nicer front entrance. Three things then converge, usually in the same year: The first enterprise customer. Their security que

Every infrastructure post-mortem contains the same paragraph, and it is never the one anyone expected to write. The initial access was not sophisticated. It was a credential that existed, that worked, and that nobody had a reason to look at — because it had been legitimately issued months earlier, for a reason that had since ended. That is standing access. It is not a vulnerability, so no scan finds it. It is not a misconfiguration, so no posture report flags it. It is the residue of a hundred reasonable decisions: a key added for a migration, a database password shared during an outage, a kubeconfig sent to a contractor who did good work and left on good terms. It stays invisible to the risk register because a risk register asks what could go wrong, and standing access is the record of things that already went right. The distribution problem The mechanism is worth being precise about, because it explains why the usual fixes only partly work. Infrastructure access is almost always handed out rather than granted . A key is copied to a host. A kubeconfig is copied to a laptop. A password is copied into a password manager and then, at two in the morning, into a chat window. Once a credential has been copied, the organisation has permanently lost the ability to list its copies. There is no query that returns the answer. Revocation stops being an operation and becomes an investigation — carried out by people, at the exact moment the person who knew where everything was has left. This is why the honest test of an offboarding process is not "did we remove their access". It is: can we show a third party, at any point in the future, that access ended when we say it ended? Most organisations that pass the first test fail the second, and usually find out during an audit or a due-diligence review, which are the two worst moments to find out. Why the obvious fixes fall short Configuration management as the source of truth is a real improvement. It makes access declarative and pu

The Networking Architecture Dilemma in Production Flutter If you survey ten seasoned Flutter developers about how they structure networking in production, you will almost certainly see the same multi-tiered pipeline: ┌────────────────────────────────────────────────────────────────────────┐ │ Traditional Flutter Networking Pipeline │ ├────────────────────────────────────────────────────────────────────────┤ │ [Dio / HTTP Client] ─▶ [API Service] ─▶ [Repository Layer] ─▶ │ │ [Cubit / BLoC] ─▶ [UI Builders & Banners] │ └────────────────────────────────────────────────────────────────────────┘ The underlying architectural principles are sound: separation of concerns, testability, and isolating network transport details from UI widgets. However, in practice, this classical layered stack demands an enormous amount of repetitive boilerplate: Async State Union Ceremony : Defining four separate state classes ( Initial , Loading , Success(data) , Failure(error) ) or union types for every single API endpoint. Race Conditions & In-Flight Cancellation : When users type queries or switch tabs rapidly, requests finish out of order. Preventing stale responses requires complex Dio CancelToken plumbing or heavy rxdart switchMap streams. Offline Caching & "Stale-While-Revalidate" : Showing cached data on Frame 1 while fetching fresh updates in the background usually requires database synchronization and stream merging logic. The Repository vs. Controller Divide : Repositories hold data and caching logic, while BLoCs or Cubits hold reactive state. Because Dart only allows single inheritance, developers end up maintaining two separate class hierarchies connected by verbose dependency injection glue. With bloc_signals , we can preserve complete separation of concerns while eliminating 70% of the friction. Let us examine how to architect a modern, clean, production-ready networking layer using CubitSignalMixin , HydratedMixin , and .toAsyncBlocSignal() . ⚡ 1. Symmetrical Async Projection

A technology problem rarely stays a technology problem for very long. A platform may need to scale. A product may need to move faster. An organisation may want to introduce AI, modernise an ageing estate, improve customer experience or launch something entirely new. The first instinct is usually to look at the technology itself. Which architecture should change? Which platform should we buy? Which team should build it? Which tools should we introduce? Those questions matter. But they are often not the questions that determine the outcome. At Cralgo, one pattern keeps appearing across technology work: the harder part is frequently the system around the technology. The problem behind the problem Consider a programme that appears to have an execution issue. Delivery is slow. Priorities keep changing. Teams disagree. Decisions are repeatedly reopened. The roadmap keeps moving. It is easy to conclude that the engineering team needs to become faster. But look closer and the constraint may be somewhere else: ownership is unclear; priorities are not genuinely ordered; product and technology are working from different assumptions; architecture decisions are being made without business context; teams are executing tasks without understanding the judgement behind them; governance exists, but only as reporting; critical decisions remain dependent on a small number of people. None of these are purely technical problems. They are questions of judgement, ownership, capability, sequencing and governance. Technology simply makes them visible. Better technology does not automatically create better execution Organisations understandably invest heavily in platforms, cloud, data, automation and AI. But technology increases capability only when the organisation around it can use that capability well. A new platform cannot decide what should be prioritised. A new operating model diagram cannot create ownership. A dashboard cannot replace judgement. AI cannot resolve ambiguity that an orga

Making the Migration from In-View Asynchrony to Synchronous State Management Truly Mechanical After our recent discussions on why FutureBuilder and StreamBuilder are architectural anti-patterns when placed inside Flutter widget trees, I started thinking: how can we make it even easier—even completely mechanical—to convert from a FutureBuilder or StreamBuilder to a BlocSignalBuilder ? Every Flutter developer knows the history. Years ago, I recorded a video breaking down the hidden traps of placing asynchronous builders in UI views: Why you shouldn't put FutureBuilder in your build method . Even the original official Flutter video on FutureBuilder initially instantiated the network future directly inside the build() method, until I filed an issue to get it corrected (which is why the official Flutter YouTube video still proudly bears "Take 2" on its clapperboard!). The fundamental issue has never been that developers want bad architecture. The issue was friction . FutureBuilder was simply the path of least resistance. To do it "properly" in traditional state management, developers had to create an entire BLoC or Cubit, declare separate Event and State classes (or union types), write boilerplate event handlers, wire asynchronous repository methods, manage subscription lifecycles, and inject everything into the widget tree. With bloc_signals 1.1.0 , that friction disappears completely. We have introduced universal, symmetrical adapter extensions that allow any Dart Future , Stream , ReadonlySignal , or lifted primitive ( value.$ ) to adapt into a synchronous BlocSignalBase container with a single method call. 🧭 The Universal Dual-Track Mental Model When bridging asynchronous sources into synchronous state management, developers typically have one of two distinct intents: Raw Domain Values ( T ): You want raw domain objects (for example int , UserProfile , ThemeMode ) with zero wrapper ceremony, and you have an immediate default or fallback value for frame 0. Rich Asynch

I'm part of an awesome community where senior devs, product managers, founders, and experienced folks from different domains discuss how they use AI and automation tools to boost productivity — without sacrificing real learning. The group is a goldmine . Tool recommendations. Automation workflows. Latest trends. Migration war stories. I've learned more from this group than from most tutorials. Last week, I needed to find something specific about running local LLMs. I searched with keywords. I scrolled. I found a whole lot of messages — but none of them answered my question directly. I still had to manually read through dozens of messages , open the links they shared, and try to piece together the context myself. It took me over an hour, and I wasn't even sure I'd found everything. Someone might say: "Just Google it." Or "Ask an LLM." But that defeats the purpose. The value here isn't just information — it's the context . The "this library is a game changer" comment only makes sense if you know what the person was working on before, and who else agreed or disagreed. That context is lost in scrollback. And I'm tired of trying to keep it all in my head . I've seen people send important links to themselves on WhatsApp. But that becomes a messy pile with no structure. No connections. No way to see how one message relates to another. So I'm curious: How do you deal with this? Have you lost important knowledge in group chats? Do you have a system for recovering it? Or are you also just scrolling endlessly? I have an idea I'm working on. But I'd love to hear your approaches first. Drop your thoughts in the comments — I'll document what I learn .

要点 呼び方の揺れにはシソーラス、置き場所の迷いにはタクソノミーが役立ちます 複数の情報がどう関係するかまで扱うなら、オントロジーを検討できます すべてを整えず、目の前の困りごとに合う方法から小さく始められます Slackで共有された仕様を探し、Notionの議事録とFigmaの画面を見比べ、GitHubのIssueで変更の経緯をたどる。情報は揃っているのに、呼び方や置き場所が違うだけで確認に時間がかかることがあります。そんな状況を整理する手がかりとして、シソーラス・タクソノミー・オントロジーという3つの考え方を眺めてみます。 情報の量だけでなく、整理の基準にも目を向ける 情報過多というと、保存する量を減らすことに目が向きがちです。ただ、同じものが違う名前で呼ばれ、保存場所が人によって変わり、情報同士の関係も見えにくいことが負担になっている場合があります。 同じ「ユーザー」という言葉でも、仕様書ではサービスの利用者、データモデルではログイン済みのアカウントを指しているかもしれません。反対に、「モーダル」「ダイアログ」「ポップアップ」のように、違う言葉で同じ画面を指していることもあります。認識を揃えないまま設計と実装が進み、後から齟齬が分かって仕様変更になった経験もあるかもしれません。 言葉と分類と関係を整理することは、情報を探しやすくするだけでなく、こうした手戻りを減らす助けにもなりそうです。3つの考え方は、それぞれ次の役割を担います。 シソーラス：言葉を揃える タクソノミー：置き場所を決める オントロジー：意味のつながりを記述する シソーラス：呼び方を揃える シソーラスは、言葉同士の関係を整理した語彙集です。同じ意味の言葉を代表語にまとめるほか、上位語・下位語や関連語も記録します。 たとえば、チーム内で同じUIを「ダイアログ」「モーダル」と呼んでいるなら、代表語を一つ決め、もう一方を同義語として結び付けられます。「オーバーレイ」を上位語、「ドロワー」を関連語として扱うこともできます。仕様書とデザインシステムで表記が違っていても、同じ情報へたどり着きやすくなるでしょう。 タグの表記揺れを抑えたいときや、社内検索で資料の取りこぼしを減らしたいときに使いやすい方法です。よく使うUI用語を一覧にして、代表語・同義語・関連語を記録するだけでも、小さなシソーラスになります。 教育文献データベースのERICでは、シソーラスの統制語を各文献に付与しています。「Indexing」には同じ検索先へ導く語や上位語、関連語がまとめられ、表現が異なる文献も共通の語彙から探せます（ ERIC Thesaurus ）。 タクソノミー：置き場所を決める タクソノミーは、情報を一定の基準で分類し、主に階層として整理する仕組みです。たとえばデザインシステムなら、「基礎」の下に「色」「余白」「文字」、「コンポーネント」の下に「入力」「ナビゲーション」「フィードバック」を置く、といった構造が考えられます。 上位の分類から下位へたどれるため、情報の全体像を見渡しやすくなります。ドキュメント、社内Wiki、デザインシステムなど、共通の置き場所を用意したい場面に向いています。 一方で、複数の軸を一つの階層へ押し込むと、迷いが生まれることもあります。「エラー表示付きの入力フォーム」は、「入力」と「フィードバック」のどちらにも置けそうです。この場合は主となる分類軸を一つ選び、ほかの軸をタグで補う方法もあります。 Google Merchant Centerでは、商品を「Apparel & Accessories > Clothing > Outerwear」のように、大きな分類から具体的な分類へ配置します。独自の商品名でも共通の階層に対応させることで、商品群の整理や広告運用の軸として使えます（ Google Merchant Centerの商品データ仕様 ）。 オントロジー：意味のつながりを記述する オントロジーは、ある領域に存在するものの種類、性質、関係、必要に応じて制約を明示したモデルです。単に「近い言葉」「同じカテゴリ」として結ぶだけでなく、何と何が、どのような意味で関係しているかを表します。 たとえば、「機能」「画面」「コンポーネント」「API」「Issue」という種類を定義し、「画面は機能を提供する」「画面はコンポーネントを使う」「機能はAPIに依存する」「Issueは機能を変更する」といった関係を記述できます。すると、「このAPIの変更で影響を受ける画面と関連Issue」のような、複数の関係をたどる問いにも答えやすくなります。 Schema.orgには「Person」「Event」「Product」などの型と属性が定義されています。Webページの情報を意味のある

If someone has ownership, when should you check on their work? Too little involvement can mean discovering problems too late. Too much involvement becomes micromanagement. I think the difference is what the checkpoint is trying to achieve . A useful checkpoint asks: “Are we still solving the right problem, and do you need anything from me?” Micromanagement asks: “Why did you do it this way? Change this. Then do this next.” The first keeps ownership with the person. The second gradually takes it away. A checkpoint can be as simple as: Agree on the approach before starting. Share an early draft. Discuss progress after a meaningful milestone. Review the result before it becomes difficult to change. The important part is that the checkpoint should happen early enough to change the outcome , without requiring the person to get approval for every decision. The amount of checking should also change with the situation. A new engineer working on an unfamiliar problem may need frequent checkpoints. Someone experienced and familiar with the problem may need very little intervention. So the goal isn’t: “Never check.” It’s: “Check enough to reduce risk without taking away ownership.” A checkpoint should help someone succeed without making them dependent on you.

For the past two months or so, I've been working on a variety of AI development projects rather than writing -- writing skills, plugins, workflows, and applications; testing and refining harnesses; and performing diligence or working with clients (hands-on work as well as brains-on work) as they think through where they're going with AI and how they're getting there. I've been down a lot of rabbit holes and talked to a lot of forward-thinking practitioners, and I have explored a lot of what is actually possible now by building things...and I've spent my "think-time" on what that all might actually mean going forward. Here's what I've come up with: 59 predictions in 17 categories around how the world of AI -- and the broader world in light of AI -- are changing. I'll write more deeply about many of these over the weeks ahead. Predictions Here's what's coming, in my not-so-humble opinion, based on what I'm seeing in client projects & diligence, conversations, and research. Each prediction is grouped by category and by time horizon (within 12 months / 1-3 years / 2-4 years / 3-5 years), with a confidence level and a falsification criteria (i.e., what I'd expect to observe if I'm wrong). Confidence isn't a measure of how much I want something to be true; it's a measure of how much variance I think exists in the outcome. I'd love your feedback on what I'm missing or where I'm missing the forest for the trees (or the boat entirely :D)! Any surprises for you? Organizational Structure & Delivery Model #1. Small Cross-Functional Pods Become the Standard for Software Development (2-4 years) The leading-edge/aspirational development team model will have moved from agile teams of 6-8 to AI-powered Pods of 2-3 (often product/development/deployment, sometimes SrDev/JrDev/Product). This prediction underpins many of the other predictions in this entire group -- most of the rest of the Org Structure & Delivery Model cluster assumes it holds. It's plausible for greenfield and startup

Berry Street founder Noah Kotlove and Healthify founder Tushar Vashisht will act as co-CEOs of the new entity.

AI can produce an answer in seconds. The answer may be clear, plausible, and even correct. Yet something about it can still feel wrong. I do not think this discomfort comes only from hallucinations or poor model accuracy. Sometimes the real problem is simpler: The AI returned an output, but it did not return the work in a form that another person can safely continue. This is not a new problem created by AI. It is the same problem we already have when delegating work to another person. What do we expect when we delegate work? Imagine a manager asking a team member: Please prepare a proposal for reducing next month's operating costs. The team member reviews several documents, compares multiple options, and replies: We should choose Option A. The requested conclusion has been delivered. But has the work really been handed back? The manager still does not know: What objective the team member optimized for Which documents and facts were examined Which assumptions and constraints were used Which alternatives were compared Why Option A was preferred Which conditions remain unverified What must be reconsidered if the situation changes The original request may not have explicitly demanded all of this. Even so, we normally expect a competent team member to understand the purpose of the assignment and to return enough information for someone else to review, approve, revise, and continue the work. That information is not additional reporting attached to the work. It is part of the handoff condition that makes delegation possible. AI often returns the conclusion without the handoff Now replace the team member with an AI assistant. The AI immediately recommends Option A and produces a polished explanation. Because the answer arrives so quickly and looks complete, it is easy to confuse the existence of an output with the completion of the work. But the same questions remain: How did the AI interpret the objective? What was considered in scope and out of scope? Which sources were a

The private equity giant confirms a breach, weeks after Google researchers said hackers were targeting financial companies.

Microsoft has made the Azure DevOps Remote MCP Server generally available, offering a hosted endpoint into work items, repos, and pipelines with nothing to install. Claude Desktop, Claude Code, ChatGPT, and Cursor cannot connect yet because Entra lacks support for dynamic client registration and Client ID Metadata Documents. By Steef-Jan Wiggers

I expected the audit to find broken code. That's what I was bracing for going in — a pile of half-working features, sloppy logic, the kind of mess you'd assume from software built at maximum speed with no human reviewing every line. That's not what I found. Almost everything Claude built actually worked, taken piece by piece. What I found instead was something I didn't expect at all: the agent had made the exact same mistakes I've watched human startup teams make, over and over, when they move fast and nobody's job is to say no. That's the real story here, and it's more interesting than "AI wrote bad code" would have been. The experiment The project is called GetPricePulse — a SaaS pricing intelligence product. It's Claude's entry from The $100 AI Startup Race , the season-long challenge I run where seven AI agents each get $100 and full autonomy to build a real startup from scratch, with no human coding and no product manager in the loop. Each agent picked its own idea and ran with it. Claude picked SaaS pricing intelligence, named it PricePulse, and kept building on it for the entire race. That "no product manager in the loop" part is the thing that made this interesting to watch. Nobody was deciding what PricePulse should be. Nobody was saying "we have enough pricing tiers now" or "this feature doesn't belong here." Claude got to build exactly what its own priorities told it to build, at whatever speed it chose, for the length of the race — optimizing, as far as I could tell from the commit history, for speed, feature creation, shipping, and monetization experiments. Not correctness. Not coherence. Not "does this still make sense in three weeks." I've written before about what all seven agents in this race said, independently, when I asked them what AI agents still can't do — they converged on the same answer without seeing each other's responses. This piece is narrower: a full production audit of Claude's specific build, PricePulse, done after the race, before I

Ramp has launched its own AI model routing service, dubbed Router, that lets users and companies use and switch between various large language models via an API.

Nintendo had a hotline where gamers could, at the time, call and speak with 'Game Counsellors' who provided them with tips and walkthroughs. It operated for quite sometime before Nintendo sunset it. There are a few (Product) lessons from this that I am sure will be of value to Product Leaders. 1- Necessity (Invention's mother) : The necessity of a situation usually births the creation of something that stands out from the rest. While Nintendo was not the first to use a phone as a 'business' function, it proved it can be used in the context of a video gaming community. That was their ‘necessity’. "We need a way to accomplish ‘xyz’ " usually turns to creating something specific to that situation. The ‘xyz’ in Nintendo’s case was supporting gamers instantly. It could also be something to support a Product or make it easier for the customer. It could be a feature or it could even be the Product itself. All we need to do is pay attention to our necessities, needs and allow it to guide us. Most people are not paying attention to their needs that’s why innovation and improvements appear difficult. Others know what their necessities are but prioritise wrongly – well that’s story for another day. The point here is simply to build for a necessary problem that exists and not out of assumptions. 2- Know what is available immediately : If necessity is calling, we cannot keep it waiting. We need to look around to know what’s available immediately. In most cases we do not need to go far for solution, we just need to pick what is close by then structure it to align with current needs. Sometimes the necessity demands using/importing an idea from some other place into your own specific area. In retrospect, Nintendo had other options it could have considered at that era in time. During that period, it was common to use print media to relate with the computer (and also gaming) community. There was also postal mail, bulleting boards. I do not know for sure but I am guessing the team at