As generative artificial intelligence (GenAI) capabilities evolve, software architects and developers face critical decisions about when to use GenAI-based solutions versus traditional programming approaches. A systematic, four-dimensional decision framework guides technology selection in application design.

While traditional programming offers faster implementation for straightforward tasks with full transparency, GenAI-based solutions demand significant computational resources and training time but enable sophisticated handling of complex, personalized interactions. A hybrid architectural strategy provides concrete criteria for technology selection that reconcile software engineering limitations and GenAI capabilities.

The 4-Dimensional Decision Framework

Before defaulting to or dismissing GenAI, architects can take a systematic approach to evaluate each feature against four practical dimensions to determine whether GenAI will add value or create unnecessary complexity and costs.

1. Reasoning versus logic. Does the feature require adaptive interpretation of ambiguous inputs or intentions, or does it follow predictable rules? GenAI excels in tasks involving pattern matching across messy inputs where all possibilities can’t be enumerated upfront. Deterministic code is best suited to handle behaviors that can be expressed as explicit rules, such as routing requests based on user permissions and eligibility decisions that follow clear logic trees.
2. Data type. What format are the primary inputs and outputs? Traditional code struggles with unstructured data that resists traditional parsing. GenAI is better suited for unstructured data, while traditional code excels at handling structured data.
3. Scalability profile. How many times per second will this function run, and what is the cost tolerance per execution? GenAI is well-suited to moderate-volume interactions where adaptive decision-making justifies the higher cost per call. Traditional code is the better option for high-throughput operations that must handle tens of thousands of requests per second at fractions of a cent each.
4. Task complexity. How many edge cases and conditional paths exist? GenAI is designed to handle workflows where the path forward depends on unpredictable or ambiguous factors, like customer intent. Using GenAI to manage simple linear tasks with clear success criteria that can be handled by programmable code is excessive and expensive.

Klarna’s GenAI customer service chatbot aligned with these criteria. The “buy now, pay later” payment company determined that customer messages, which contain unstructured text with ambiguous intent and emotional context that require interpretation across 35 languages, warranted the use of GenAI. Structured operations that required calculations, audit trails and regulatory compliance, such as authentication and payment processing, remained in traditional code.

Klarna later refined its approach, using GenAI to handle two-thirds of inquiries, while directing more complex cases that require judgment and empathy to humans. The result demonstrated an effective division of labor. GenAI interprets and routes requests, while deterministic systems handle execution and judgment.

3 Critical Trade-Offs in Practice

Once features are mapped against the four-dimensional framework, balancing three operational trade-offs further refines the decision whether the GenAI approach justifies its costs.

The first trade-off is time-to-market. GenAI accelerates features centered on language interaction, summarization or question answering. Building a hypothetical “Ask our docs” feature requires less development time with GenAI than with traditional approaches.

Traditional programming wins on speed when building crisp, rule-based features like order status tracking. When business rules are clear, features can be implemented, tested and deployed in days without the GenAI overhead of prompt engineering, model selection or accuracy evaluation.

The second trade-off is transparency and explainability. Financial calculations, access control, compliance checks and safety-critical operations demand complete transparency. When auditors ask why a fee was charged or regulators question a claim denial, deterministic code provides traceable logic. GenAI models produce outputs through billions of learned parameters that cannot guarantee reproducible reasoning paths.

Consider a fee calculation service processing 1 million transactions monthly: Deterministic code achieves essentially 100% accuracy for valid inputs. Recent studies on GPT model behavior found its accuracy rate ranging from 30% to 90%, depending on the function. Applying these rates to 1 million monthly transactions would result in over 100,000 errors, which is unacceptable for financial or compliance-critical tasks.

The final trade-off is cost structure. Traditional applications typically run on a central processing unit (CPU) infrastructure with per-request costs measuring fractions of a cent. GenAI systems introduce variable costs depending on deployment models. With external API providers, cost scales with usage through per-token pricing. A feature averaging 1,000 tokens per callcosts $20,000 monthly at $0.002 per 1,000 tokens for 10 million calls, or $100,000 monthly at higher pricing. Self-hosted models’ costs shift to GPU infrastructure, resulting in a higher upfront investment but lower marginal cost per request.

Beyond compute, GenAI introduces additional governance costs. The economics shift when GenAI replaces substantial human labor. Bank of America’s Erica chatbot relies on deterministic natural language processing GenAI to resolve 98% of support interactions autonomously,contributing to a 19% earnings upliftthat far exceeds the GenAI infrastructure costs.

Implementing Hybrid Architecture

Successful production systems use one of three architectural templates to structure the relationship between GenAI and traditional code at the system level.

Template No. 1: GenAI Interprets, Code Executes.

This template is effective when natural user experience is critical, but transactional operations require precision. A customer types, “Can you refund my last order and ship the replacement to my office?” GenAI parses intent and extracts structured elements, such as a refund request, order identifier or delivery address. Traditional services then verify ownership, determine refund eligibility, calculate amounts, call payment and shipping APIs, and update databases.

Template No. 2: GenAI Generates, Code Validates.

When creative or summary output is needed within strict boundaries, this template is appropriate. For example, a support agent uses GenAI to draft customer responses quickly by reviewing ticket history and generating suggested text. Code-based validation ensures that no personally identifiable information (PII) is leaked, that refund amounts match actual records and that responses comply with policy requirements. GenAI provides speed and quality, while deterministic guardrails ensure compliance violations never reach customers.

Template No. 3: GenAI Captures Knowledge, Code Enforces Facts.

Cleveland Clinic uses a GenAI scribe platform to document patient interactions. With patient consent, the system listens to patient calls and drafts clinical notes, which providers review before adding them to medical records. To date, the tool has documented more than 1million patient interactions, saving providers an average of 14 minutes per day. The GenAI-generated notes are then used by revenue cycle systems to reduce billing and coding issues downstream. The GenAI applies contextual knowledge to generate accurate records, while the code uses factual elements to complete traditional functions.

Hybrid Architecture: It’s Not Either/Or, but Yes

Choosing between GenAI and traditional code doesn’t require complex analysis. These frameworks and templates provide a systemic approach to GenAI adoption, but it’s essential that they don’t become obstacles to making clear decisions. A practical checklist helps move analysis to execution.

• Start with the verb. If the feature helps, suggests or explains, consider GenAI. If it calculates, enforces or guarantees outcomes, deterministic code might be a better option.
• Assess the feature’s acceptable error rate and latency. Can the system tolerate occasional inaccuracies? Does it require sub-50 millisecond response times? Identifying these operational constraints helps eliminate unsuitable approaches.
• Determine which outcomes matter most. Common metrics include cost per successful task, time to resolution and user satisfaction, not GenAI model sophistication.

GenAI excels at interpreting ambiguous inputs and generating insights, while traditional code takes ownership of decisions and irreversible actions. This division of responsibility captures GenAI’s strengths without sacrificing the reliability that business operations demand.

The post When To Use GenAI: A Practical Decision Framework appeared first on The New Stack.

If 2025 was “the year of type checking and language server protocols” for Python, will 2026 be the year of the type server protocol? “Transformative” developments like free threading were said to be coming to Python in 2026, along with performance-improving “lazy” imports for Python modules. We’ll (hopefully) also be seeing improved Python agent frameworks.

But 2026 could even see a change in change itself — in the ways that Python changes are proposed.

Last month, there was an illuminating seven-person conversation — including three of Python’s core developers, two of whom are also members of Python’s Steering Council. As 2025 came to a close, these prominent guests came together for a special year-in-review episode of the “Talk Python to Me” podcast, discussing what trends they’d seen in 2025 — but also what they see coming in the year ahead for Python and its developer community.

Tools That Run Python

From the beginning, the podcast showed that Python is still a broad-based global community. From Vancouver came Brett Cannon, a Python core developer since 2003, and a Microsoft principal software engineer for over 10 years. And what Cannon saw in 2025 was advances in people running Python code using tools.

Where before you’d install the Python interpreter — and then also any needed dependencies — to then launch everything in a virtual environment, “Now we’ve got tools that will compress all that into a run command!” A growing set of tools like Hatch, BDM and uv “build on each other and … just slowly build up this repertoire of tool approaches.”

This caught the attention of Python’s core developers. “These tools treat Python as an implementation detail, almost,” Cannon said. The Python interpreter just fades into the background as “a thing that they pull in to make your code run.”

Also on the call was Barry Warsaw, who has been a Python core developer for more than 30 years. He told Cannon, “I think you’re really onto something.” Warsaw is also on the 2026 Python Steering Council (while currently working on Python at Nvidia), and sees this as an even larger trend — “a renewed focus on the user experience.”

Just installing the binary with the Python interpreter can be complicated for new users, but 2024 saw Python adding a format for metadata to embed in Python scripts to help IDEs, launchers and other external tools. So in the world of 2025, it’s now that much easier to write code that will be run by Python. “You can put uv in the shebang line of your script — and now you don’t have to think about anything. And Hatch can work the same way for developers.”

This drew some enthusiastic agreement from Associate CS Professor Gregory Kapfhammer. Dialing in from Pittsburgh (where he’s already using uv in his classes at Allegheny College), Kapfhammer said he’s amazed how much uv had simplified lessons for his students. “I don’t have to teach them about Docker containers, and I don’t have to tell them how to install Python with some package manager.”

And from Berlin came more agreement from Jodie Burchell, a 10-year data scientist (now a developer advocate at JetBrains, working on PyCharm). Burchell said they’re even discussing whether to use uv at the data science mentoring community Humble Data (where she’s one of the organizers). “It does abstract away all these details. The debate I have is, is it too magic?” And as a developer advocate at JetBrains, “It’s also a debate we have in PyCharm. How much do you magic away the fundamentals versus making people think a little bit?”

This led to a discussion about possible future developments in Python. Core developer Cannon said that for the troubleshooters — and even just for the curious — “I want the magic to decompose. You should be able to explain the ‘magic’ path via more decomposed steps using the tool all the way down to what the tools actually do behind the scenes.” And it’s not just a hypothetical for him. “I’ve been thinking about this a lot,” Cannon said, because “I’m thinking of trying to get the Python launcher to do a bit more.”

After all, uv is still made by a company (named Astral), and “There’s always the risk they might disappear.” And a lot of work has now been put in place to create standards for this kind of packaging, including that metadata addition.

Lazy Imports and Free-Threaded Python

2026 will also bring performance-improving “lazy imports,” which will speed start-up times by deferring until first use the importing of modules. “It’s been accepted, and it’s going to be awesome,” said Core Developer Thomas Wouters. Dialing in from Amsterdam, Wouters has also deployed Python internally at Google, where he worked for 17 years before moving to Meta. He’s been a board member of the Python Software Foundation — even receiving their Distinguished Service Award in 2025 — and is a current member of 2026’s Python steering council.

Wouters is even more excited about Python’s progress toward adding parallel processing capabilities. Thinking of how Python’s Global Interpreter Lock notoriously slowed down performance by enforcing single-thread processing, Wouters phrased this development indelicately as “the global interpreter lock is going away! I am stating it as a fact — it’s not actually a fact yet, but that’s because the Steering Council hasn’t realized the fact yet.”

Wouters said this because he was on the Steering Council that accepted an alternative — free-threading — as an experimental feature, and now for Python 3.14, “It is officially supported. The performance is great … It’s basically the same speed on MacOS … That’s a combination of the ARM hardware and clang specializing things … And then on recent GCCs on Linux, it’s like a couple percent slower.”

2026 will see a focus on community adoption, said Wouters, “getting third-party packages to update their extension modules for the new APIs” and “supporting free-threading in a good way.” But for Python code, “it turns out there’s very few changes that need to be made for things to work well under free-threading.”

And more to the point, “We’ve seen a lot of examples of really promising, very parallel problems that now speed up by 10x or more. And it’s going to be really exciting in the future.”

Enhancing the Enhancement Proposals?

The biggest change may have been suggested by Barry Warsaw. As the creator of Python Enhancement Proposals — the procedure for changing the language — Warsaw brings real credibility when he said, “We have to rethink how we evolve Python — and how we propose changes to Python, and how we discuss those changes in the community.”

The current process is over a quarter of a century old, and while the developer community is “somewhat larger,” Warsaw said there’s been a more exponential growth in “the number of people who are using Python and who have an interest in it.” But more to the point, “One of the things that I’ve heard over and over and over again is that authoring Python Enhancement Proposals is incredibly difficult, and emotionally draining. It’s a time sink, and leading those discussions on discuss.Python.org … can be toxic at times, and very difficult.”

The end result? “It has become really difficult to evolve the language and the standard library and the interpreter … We need to think about how we can make this easier for people and not lose the voice of the user.”

When it comes to the Python community, comments left at discuss.python.org are “the tip of the iceberg,” Warsaw said. “We’ve got millions and millions of users out there in the world who, for example, lazy imports will affect — free threading will affect. And yet they don’t even know that they have a voice.” Warsaw hopes to represent them “in a much more collaborative and positive way.”

So in 2026, Warsaw said, “I think this is something I’m going to spend some time on, trying to think about — you know, and talk to people about — ways we can make this easier for everyone.”

Warsaw shared an interesting observation on where we are now. “There have been changes that have been made to Python that really should have been a PEP. And they aren’t because … core developers don’t want to go through this gauntlet!

“But that’s also not good because then, you know, we don’t have the right level of consideration.”

When Types Meet Tools

Kapfhammer shared an important tip, pointing out that “If you can teach your AI agent to use the type checkers and use the LSPs, it will also generate better code for you.” It’s giving the large language model (LLM) one more useful piece of information and context — and the industry is starting to take notice. Kapfhammer said the team behind Meta’s type checker is working directly with Pydantic AI to create interoperability, “So that when you’re building an AI agent using Pydantic AI, you can also then have better guarantees when you’re using Pyrefly as your type checker.”

In fact, for Kapfhammer, 2025 was “the year of type checking and language server protocols.” He uses the static type checker Mypy and language server protocols like Pyright or PyLance. But 2025 also brought Meta’s Pyrefly type checker/LSP, Astral’s ty and a new type checker/LSP called Zuban. He notes these 2025 tools were all implemented in Rust — and are “significantly faster,” which changes how he uses the tools, and how often. “It’s helped me to take things that might take tens of seconds or hundreds of seconds, and cut them down often to less than a second.”

Cannon noted that “It takes more work to write Rust code than it does to write Python code,” and applauded the tool makers for being willing to shoulder that extra effort to deliver “an overall win for the community.”

But Cannon also seemed to have some high hopes for what we’ll see in 2026. “Pylance is actually working with the Pyrefly team to define a type server protocol [TSP] so that a lot of these type servers can just kind of feed the type information to a higher-level LSP, and let that LSP handle the stuff like symbol renaming and all that stuff.”

The podcast was hosted by Michael Kennedy, a Portland-based Python enthusiast and educator, who gave the 84-minute conversation — and the year ahead — a perfect summation.

“I still think it’s an incredibly exciting time to be a developer or a data scientist. There’s so much opportunity out there … Every day is slightly more amazing than the previous day … I love it.”

The post Python: What’s Coming in 2026 appeared first on The New Stack.

GameStop CEO Ryan Cohen is in line to potentially earn $35 billion in stock options, so long as the company hits a $100 billion market cap. One way to hit that target is by cutting costs, and one way of cutting costs is to close down a bunch of stores. The company closed 590 stores in fiscal year 2024, and said in a recent SEC filing that it anticipates "closing a significant number of additional stores in fiscal 2025." With the fiscal year set to end on January 31st, it appears the race is on, and according to a blog tracking closures, GameStop is planning on shuttering (or already has) over 430 stores this month.

As of Sunday, January 11t …

Read the full story at The Verge.

Get caught up on the latest technology and startup news from the past week. Here are the most popular stories on GeekWire for the week of Jan. 4, 2026.

Sign up to receive these updates every Sunday in your inbox by subscribing to our GeekWire Weekly email newsletter.

Most popular stories on GeekWire

Bill Gates makes nearly $8B payout to Melinda French Gates as part of divorce settlement

The money shows up in tax filings as a 2024 donation to French Gates’ Pivotal Philanthropies Foundation. … Read More

Tech Moves: Amazon leader lands at Anthropic; Microsoft government affairs vet retires

Steven Maheshwary, a former generative AI leader at Amazon, is now a go-to-market lead in strategic partnerships at Anthropic, the AI giant behind Claude and backed by Amazon. … Read More

Tech Moves: AWS VP switches roles; Seattle’s new economic development head; Microsoft Teams exec departs

An AWS VP is switching roles; Seattle gets a new economic development lead; a Microsoft Teams VP departs; and more in the latest tech moves. … Read More

Amazon tees up new private label golf balls — here’s how they stack up against Titleist and Taylormade

Amazon is taking a swing at golf balls, but are they worth buying? … Read More

Ring around the parking lot: Amazon’s security company unveils a $5,000 surveillance trailer

Amazon’s Ring is taking its home-security technology into the parking lot with a $5,000 solar-powered surveillance trailer aimed at construction sites, retail centers, and outdoor events — a move that puts the doorbell maker into more direct competition with commercial security providers. … Read More

Desney Tan leaves Microsoft after 21 years leading key research and healthcare initiatives

Microsoft Research leader Desney Tan is leaving the company after 21 years, closing a career that spanned breakthrough work in human-computer interaction, health “moonshots,” and products including Xbox Kinect and Microsoft Band. … Read More

Ex-Expedia employee gets 4 years for planting spy cameras across Seattle campus in voyeurism case

A former Expedia Group employee who secretly recorded women by hiding spy cameras throughout the company’s Seattle headquarters — including in bathrooms — was sentenced Friday to four years in prison. … Read More

Tech Moves: Amazon AI leader joins Google Cloud; Meta taps new chief legal officer from Microsoft

— Karthik Ramakrishnan, who spent the past 14 years at Amazon where he helped develop the company’s AI strategy, has taken a VP role within the Data Cloud organization at Google Cloud. … Read More

Trapped at a Tesla Supercharger: A comedy of errors and lessons learned from a first EV road trip

By the time we hit Kelso, it was clear my family’s post-Christmas EV adventure was hitting the skids. … Read More

Microsoft acquires data analytics startup Osmos to fuel push into ‘autonomous data engineering’

Instead of selling tools alongside data platforms, Osmos’ technology will live inside one. … Read More

Not that long ago I became aware of Justine Tunney’s cosmopolitan libc project. It’s a toolkit that allows you to compile C source code into a single binary that runs natively on multiple operating systems, including Windows, Linux, various flavours of BSD, even including booters.

Unfortunately, back the project doesn’t seem to support GUI interfaces and produces quite swollen binaries. Hence I decided to take a stab at a similar (simpler? harder? up to you to decide) challenge: create a video game (<16 KiB) that runs natively on Windows, Linux and in the Browser, all from a single source file.

The Game

It’s a pretty standard Snake game with the same rules and interface on all platforms. You control a snake that grows longer as it eats food, and the goal is to avoid running into walls. The snake is controlled using either the arrow keys or WASD keys. It can be terminated via ESC (if permissible by the platform), reset via R, and paused via P. Spacebar starts the game.

The game keeps track of your score. Each piece of food eaten increases your score by 10 points, except yellow fruit (which spawns with a 15% chance) that gives you 20 points. Fruit spawns at a fixed rate and despawns after a certain time if not eaten. The despawn timer is proportional to the speed of the snake at the time of spawning, which itself is proportional to the snake’s length.

Once ten fruit are eaten, the game proceeds to the next level, randomizing the walls’ layout. The maze is created as to ensure that there is always a path from the snake’s head to any piece of food. The initial placement of the snake is also randomized, but always in a position that has at least five empty tiles in the direction the snake is facing.

Download the game here (13,772 bytes).

The Polyglot

I implemented the game three times in total: once in C for the i686 Visual C platform using WinAPI, once in C for the x86_64 Linux platform using clang and X11, and once in JavaScript for the browser using HTML5 Canvas. Each implementation is around 3-5 KiB in size when compiled/minified.

The Windows implementation was produced using a compressing script that prepends a decompressing stub. This stub has a quite unusual PE header that has many freely controllable bytes after the MZ signature. This allows us to place a shell script there that skips over the remainder of the file, rendering the (valid) PE executable runnable on Windows while also making the entire file a valid shell script, that will do (thus far) nothing on Linux.

The Linux implementation was produced using a similar approach; we use lzma for decompression and a small shell dropper that extracts the compressed ELF64 binary and runs it, skipping over the head and the tail of the file.

The HTML version is also packed and abuses the fact that browsers will happily process all the benign garbage at the start of the file before reaching the actual HTML content. Then we make it invisible/unobtrusive through a bit of CSS magic.

Finally, we concatenate all three files together in such an order that each platform will pick the correct part of the file to execute. The final file is exactly 13,312 bytes in size.

Technical Details

0000: 4d5a 3d3b 3a3c 3c27 6b73 270a 5045 0000  MZ=;:<<'ks'.PE..  <- Windows PE header start
0010: 4c01 0000 01db 617f 10d0 1773 7947 ebf9  L.....a....syG..     As shell script: assign to MZ,
[Snip: i686 Windows code.]                                          start ignored heredoc to skip
1040: c6aa 3cb1 246e a942 ae6f 3e70 4979 9c58  ..<.$n.B.o>pIy.X     to the 'ks' marker.
1050: 344d 2d09 88b1 fbd3 9e68 401c bfff e5ab  4M-......h@.....
1060: cba1 731a 6b79 6c04 54df 9602 0a6b 730a  ..s.kyl.T....ks.  <- 'ks' marker
1070: 7461 696c 202d 632b 3432 3934 2024 307c  tail -c+4294 $0|  <- Drop 4292 bytes (PE), keep 5061 (ELF).
1080: 6865 6164 202d 6320 3530 3631 7c6c 7a6d  head -c 5061|lzm  <- Decode into /tmp/a, mark executable,
1090: 6120 2d64 633e 2f74 6d70 2f61 3b63 686d  a -dc>/tmp/a;chm     run and cleanup.
10a0: 6f64 202b 7820 2f74 6d70 2f61 3b28 2f74  od +x /tmp/a;(/t
10b0: 6d70 2f61 2672 6d20 2f74 6d70 2f61 293b  mp/a&rm /tmp/a);
10c0: 6578 6974 0a5d 0000 4000 ffff ffff ffff  exit.]..@.......
10d0: ffff 003f 9145 8468 3d89 a6da 8acc 93e2  ...?.E.h=.......
10e0: 4ed9 0498 44e9 9d40 f246 7273 6131 ea63  N...D..@.Frsa1.c
[Snip: LZMA-packed x86_64 Linux code.]
2460: de86 e198 4589 dc46 cd5b c84f 6218 4861  ....E..F.[.Ob.Ha
2470: 16af 0622 18a1 8a86 371d 2b5a 7948 7761  ..."....7.+ZyHwa
2480: 6439 4cc7 27ff fbda fb1c 3c68 746d 6c3e  d9L.'.....<html>  <- Start of HTML content
2490: 3c74 6974 6c65 3e53 6e61 6b65 3c2f 7469  <title>Snake</ti
24a0: 746c 653e 3c73 7479 6c65 3e64 6976 7b68  tle><style>div{h
24b0: 6569 6768 743a 3130 3025 3b6d 6172 6769  eight:100%;margi
24c0: 6e3a 303b 6261 636b 6772 6f75 6e64 3a23  n:0;background:#
24d0: 3163 3163 3163 7d64 6976 7b64 6973 706c  1c1c1c}div{displ
24e0: 6179 3a67 7269 643b 706c 6163 652d 6974  ay:grid;place-it
24f0: 656d 733a 6365 6e74 6572 7d63 616e 7661  ems:center}canva
2500: 737b 696d 6167 652d 7265 6e64 6572 696e  s{image-renderin
2510: 673a 7069 7865 6c61 7465 643b 6f75 746c  g:pixelated;outl
2520: 696e 653a 307d 2a7b 6d61 7267 696e 3a30  ine:0}*{margin:0  <- CSS to hide the garbage
2530: 3b70 6164 6469 6e67 3a30 3b66 6f6e 742d  ;padding:0;font-     and the padding of elements.
2540: 7369 7a65 3a30 3b7d 3c2f 7374 796c 653e  size:0;}</style>
2550: 3c64 6976 3e3c 6361 6e76 6173 2068 6569  <div><canvas hei
2560: 6768 743d 2234 3830 2220 6964 3d22 6322  ght="480" id="c"
2570: 2074 6162 696e 6465 783d 2230 2220 7769   tabindex="0" wi
2580: 6474 683d 2236 3430 223e 3c2f 6361 6e76  dth="640"></canv
2590: 6173 3e3c 2f64 6976 3e3c 7363 7269 7074  as></div><script
[Snip: Packed JavaScript code for the game.]
3590: 5d2f 2e65 7865 6328 7229 3b29 7769 7468  ]/.exec(r);)with
35a0: 2872 2e73 706c 6974 2861 2929 723d 6a6f  (r.split(a))r=jo
35b0: 696e 2873 6869 6674 2829 293b 6576 616c  in(shift());eval
35c0: 2872 293c 2f73 6372 6970 743e            (r)</script>