Minimal Basic (or QBasic)

AI——修改UI的SKILL 本技能用于RYB_GCP_SETTLEMENT_V2医疗智能柜项目Android端UI美化,基于XML与Material设计规范,严格遵循“只改UI、不碰逻辑”原则。统一使用lib_ui中定义的设计令牌(如主色#467DE4、圆角12dp卡片区等),逐模块改造布局样式,确保字号(20–36sp)、资源引用及视图ID不变。每次仅改一两个模块,先输出方案待确认,再编译验证(需JDK 11)。已完第一批,第二批待确认,其余模块按相同规范推进。 阅读详情


Project 2: Minimal Basic (or QBasic)
Please compress your source code using 7z and upload the 7z file to oc.sjtu.edu.cn before the final deadline.
 
In 1975, Bill Gates and Paul Allen started the company that would become Microsoft by writing a BASIC interpreter for the first microcomputer, the Altair 8800 developed by the MITS corporation of Albuquerque, New Mexico. By making it possible for users to write programs for a microcomputer without having to code in machine language, the Altair and its implementation of BASIC helped to start the personal computer revolution.
In this project, your mission is to build a minimal BASIC interpreter. You need to accomplish the following objectives:
➢ To increase your familiarity with expression trees and class inheritance. 
➢ To give you a better sense of how programming languages work. Learning how an interpreter operates—particularly one that you build yourself—provides useful insights into the programming process. 
➢ To offer you the chance to adapt an existing program into one that solves a different but related task. The majority of programming that people do in the industry consists of modifying existing systems rather than creating them from scratch. 
What is BASIC? 
The programming language BASIC—the name is an acronym for Beginner’s All-purpose Symbolic Instruction Code—was developed in the mid-1960s at Dartmouth College by John Kemeny and Thomas Kurtz. It was one of the first languages designed to be easy to use and learn. Although BASIC has now pretty much disappeared as a teaching language, its ideas live on in Microsoft’s Visual Basic system, which remains in widespread use. 
In BASIC, a program consists of a sequence of numbered statements, as illustrated by the simple program below: 
10 REM Program to add two numbers
20 INPUT n1
30 INPUT n2
40 LET total = n1 + n2
50 PRINT total
60 END
The line numbers at the beginning of the line establish the sequence of operations in a program. In the absence of any control statements to the contrary, the statements in a program are executed in ascending numerical order starting at the lowest number. Here, for example, program execution begins at line 10, which is simply a comment (the keyword REM is short for REMARK) indicating that the purpose of the program is to add two numbers. Lines 20 and 30 request two values from the user, which are stored in the variables n1 and n2, respectively. The LET statement in line 40 is an example of an assignment in BASIC and sets the variable total to be the sum of n1 and n2. Line 50 displays the value of total on the console, and line 60 indicates the end of execution. A sample run of the program therefore looks like this:

Figure 1
Line numbers are also used to provide a simple editing mechanism. Statements need not be entered in order, because the line numbers indicate their relative position. Moreover, as long as the user has left gaps in the number sequence, new statements can be added in between other statements. For example, to change the program that adds two numbers into one that adds three numbers, you would need to make the following changes: 
1. Add a new line to read in the third value by typing in the command
35 INPUT n3
2. This statement is inserted into the program between line 30 and line 40. Replace the old line 40 with an update version by typing
40 LET total = n1 + n2 + n3
 
In classical implementations of BASIC, the standard mechanism for deleting lines was to type in a line number with nothing after it on the line. Note that this operation actually deleted the line and did not simply replace it with a blank line that would appear in program listings. 
Expressions in BASIC 
The LET statement illustrated by line 40 of the addition program has the general form
LET variable = expression 
and has the effect of assigning the result of the expression to the variable. In Minimal BASIC, the assignment operator is no longer part of the expression structure. The simplest expressions are variables and integer constants. These may be combined into larger expressions by enclosing an expression in parentheses or by joining two expressions with the operators +, -, *, /, and MOD. You only need to support +,-, *, /, MOD, (, ) operators with signed integers (at least 32-bit) in expressions. (Be aware of negative integers.)
The MOD operator has the same precedence as * and /. In the expression LET r = a MOD b, the absolute value of rshould be less than the absolute value of b, and the sign of ris the same as that of b. For example, 5 MOD 3 is 2 and 5 MOD (-3) is -1.
Additionally, you need to support the exponentiation operator in expressions:
exp1 ** exp2
The exponentiation operator returns the result of exp1exp2, where exp1 and exp2 are expressions. The exponentiation operator is right associative, i.e., a ** b ** c is equal to a ** (b ** c). The operator has higher precedence than *, / and MOD.
 
For all expressions and statements, you need to handle extra spaces. For example, LET a   = b + 4 *   (-5 + 4 ).
 
Control statements in BASIC 
The statements in the addition program illustrate how to use BASIC for simple, sequential programs. If you want to express loops or conditional execution in a BASIC program, you have to use the GOTO and IF statements. The statement 
GOTO n 
transfers control unconditionally to line n in the program. If line n does not exist, your BASIC interpreter should generate an error message informing the user of that fact. 
The statement 
IF condition THEN n 
performs a conditional transfer of control. On encountering such a statement, the BASIC interpreter begins by evaluating condition, which in the minimal version of BASIC consists of two arithmetic expressions joined by one of the operators <, >, or =. If the result of the comparison is true, control passes to line n, just as in the GOTO statement; if not, the program continues with the next line in sequence. 
For example, the following BASIC program simulates a countdown from 10 to 0: 
10 REM Program to simulate a countdown
20 LET T = 10
30 IF T < 0 THEN 70
40 PRINT T
50 LET T = T - 1
60 GOTO 30
70 END
Even though GOTO and IF are sufficient to express any loop structure, they represent a much lower level control facility than that available in C++ and tend to make BASIC programs harder to read. The replacement of these low-level forms with higher level constructs like if/else, while, and for represented a significant advance in software technology, allowing programs to represent much more closely the programmer’s mental model of the control structure.
Summary of statements available in the minimal BASIC interpreter 
The minimal BASIC interpreter implements only six statement forms, which appear in Table 1. The LET, PRINT, and INPUT statements can be executed directly by typing them without a line number, in which case they are evaluated immediately. Thus, if you type in (as Microsoft cofounder Paul Allen did on the first demonstration of BASIC for the Altair) 
PRINT 2 + 2
your program should respond immediately with 4. The statements GOTO, IF, REM, and END are legal only if they appear as part of a program, which means that they must be given a line number. 
Commands recognized by the BASIC interpreter 
In addition to the statements listed in Table 1, BASIC accepts the commands shown in Table 2. These commands cannot be part of a program and must therefore be entered without a line number. 
Table 1. Statements implemented in the minimal version of BASIC
REM    This statement is used for comments. Any text on the line after the keyword REM is ignored. 
 
LET    This statement is BASIC’s assignment statement. The LET keyword is followed by a variable name, an equal sign, and an expression. As in C++, the effect of this statement is to assign the value of the expression to the variable, replacing any previous value. In BASIC, assignment is not an operator and may not be nested inside other expressions. 
 
PRINT    In minimal BASIC, the PRINT statement has the form: 
PRINT exp
where exp is an expression. The effect of this statement is to print the value of the expression on the console and then print a newline character so that the output from the next PRINT statement begins on a new line.
 
INPUT    In the minimal version of the BASIC interpreter, the INPUT statement has the form: 
INPUT var
where var is a variable read in from the user. The effect of this statement is to print a prompt consisting of the string " ? " and then to read in a value to be stored in the variable. (The string " ? " should display in the command input edit box in GUI.)
 
GOTO    This statement has the syntax
GOTO n
and forces an unconditional change in the control flow of the program. When the program hits this statement, the program continues from line n instead of continuing with the next statement. Your program should report an error if line n does not exist.
 
IF    This statement provides conditional control. The syntax for this statement is:
IF exp1 op exp2 THEN n 
where exp1 and exp2 are expressions and op is one of the conditional operators=, <, or >. If the condition holds, the program should continue from line n just as in the GOTO statement. If not, the program continues on to the next line.
Note that the conditional operators (=, <, >) are not parts of expressions.
 
END    Marks the end of the program. Execution halts when this line is reached. This statement is usually optional in BASIC programs because execution also stops if the program continues past the last numbered line. 
 

Table 2. Commands to control the BASIC interpreter
RUN    This command starts program execution beginning at the lowest-numbered line. Unless the flow is changed by GOTO and IF commands, statements are executed in line-number order. Execution ends when the program hits the END statement or continues past the last statement in the program. 
 
LOAD    This command loads a file containing statements and commands. Statements and commands should be stored (also displayed in GUI) and executed respectively, as if they were entered into input box in order. A prompt window should be displayed when this command is entered. The window asks users to choose the file to load.
 
LIST    This command lists the steps in the program in numerical sequence. It has been required to be implemented in the previous version of this project. In the new version, your interpreter should be able to display all the codes that have been entered in real time, so there is no need to implement this command.
 
CLEAR    This command deletes the program so the user can start entering a new one.
 
HELP    This command provides a simple help message describing your interpreter.
 
QUIT    Typing QUIT exits from the BASIC interpreter.
 
 
Example of use
Figure 2 shows a complete session with the BASIC interpreter. The program is intended to display the terms in the Fibonacci series less than or equal to 10000. The three output windows are used to the current program, the standard output (and errors) of program, and the syntax tree of each line of statements. User can enter statements or commands into command input box, or load a file to be executed through LOAD button. The syntax tree is displayed only when RUN is called. CLEAR will clears the content of all three windows. The RUN and CLEAR buttons are used to execute and clear statements entered respectively. The DEBUG button is used to enter debug mode, which will discussed later.
 
Figure 2
Syntax tree display
Conceptually, syntax tree is one abstract representation of program.  More specifically, every statement in the program can be represented as a tree.  The structure of the syntax tree can be seen as the steps of the computation of the expressionin the statement. 
As you have learnt from previous programming course, some statements have side effects, in our mini basic language, the side effects include assignment and branch. And these side effects should also be displayed in the syntax tree. 
The node of the tree can be identifier definition, assignment, function call (You need not to implement function call in this project), expression computation and conditional or unconditional branch.  In your interpreter implementation, you can make the computation along the syntax tree from leaf node to root. Because the connection structures of the tree are determined by the computation rules, e.g. operator priority and association.
In your implementation, you should construct the syntax tree in infix notation.  
For displaying the syntax tree structure in your GUI window easily, you don’t need to plot the real tree. Instead, you should use indentation to display the syntax tree of each statement.
 
Followings are some concrete examples. Structure in the red border is expression of that statement. 
 
1. LET m = p + q*t
The syntax tree of this statement:
 

     LET =
   m
   +
       p
       *
           q
           t
 
Figure 3
 
2. IF m > max THEN n 
The syntax tree of this statement:
 


     IF THEN
   m
   >
   max
   n
Figure 4
3. GOTO n
The syntax tree of this statement:
    GOTOn
Figure 5
 
4. PRINT p + q*t
The syntax tree of this statement:

     PRINT
   +
       p
       *
           q
           t
Figure 6
As what you can observe, the nodes at the same level in the tree are at the same vertical line in the indentation notation.
Each indent contains 4 spaces to make the structure of the syntax tree clear enough. 
Debugger
A debugger is an essential tool for programmers. We need to implement a debugger in our BASIC interpreter with specific functionalities. The debugger should only run when debug mode is activated, so you need to design a DEBUG button that starts this mode.

Figure 7
Upon pressing the DEBUG button, the program layout will change as depicted in Figure 7. Users can manage breakpoints by adding or deleting line numbers. If an invalid line number is entered, the program should alert the user and ignore the input. Use new command formats for these actions, such as:
ADD 120
 
DELETE 110
Remember to keep the break point list up to date. Here is a possible format for it.
120130
The user can press the RUN button to start the program. The program should execute and pause when it reaches any of the specified breakpoints. Upon stopping, the debugger window should display the values of all available variables, allowing the user to inspect the program's state. A possible display format is as follows.
Max = 10000n1 = 0
While the program is paused, the user can add new breakpoints or delete existing ones. 
Pressing the RESUME button will continue the program execution from where it left off. Additionally, there should be an EXIT button that lets the user stop the program and exit debug mode at any time.
Note that code edits should be disabled in debug mode. You don’t have to persist the state of debug mode.
Storing the program 
The first task you need to undertake is making it so your BASIC interpreter can store programs. Whenever you type in a line that begins with a line number, such as 
100 REM Program to print the Fibonacci sequence 
your interpreter has to store that line in its internal data structure so that it becomes part of the current program. As you type the rest of the lines from the program in Figure 2, the data structure inside your implementation must add the new lines and keep track of the sequence. In particular, when you correct the program by typing 
145 PRINT n1 
your data structure must know that this line goes between lines 140 and 150 in the existing program. 
Hints on the statement class hierarchy 
The primary class for expressions should be Expression, which is the abstract superclass for a hierarchy that includes three concrete subclasses for the three different expression types, as follows: 

The structure of the statements is quite similar. The primary class should be Statement, which is the abstract superclass for a set of subclasses corresponding to each of the statement types, as illustrated in the following diagram: 
Even though there are more subclasses in the Statement hierarchy, it is still somewhat easier to implement than the Expression hierarchy. One of the things that makes the Expression hierarchy complex—but also powerful—is that it is recursive. Compound expressions contain other expressions, which makes it possible to create expression trees of arbitrary complexity. Although statements in modern languages like C++ are recursive, statements in BASIC are not. 
Exception handling 
Crashing the whole interpreter because your BASIC program has a syntax error would be incredibly frustrating, since you would lose everything you’d typed in up to that point. Thus, you need to use try/catch so that your interpreter responds to errors much more gracefully. 
Strategy and tactics 
As you work through this project, you might want to keep in mind the following bits of advice: 
• The last line of the fictional memo from Bill Gates encourages his team to “get going on this project as soon as possible.” I encourage you to adopt that same strategy.
• You need to first create a project and initialize the GUI. You can use the UI editor of Qt Creator or place the UI widgets by C++ code. To finish the Minimal BASIC project, you need to proceed strategically by making carefully staged edits. To whatever extent you can, you should make sure that the BASIC project continues to run at the completion of each stage in the implementation.
• Make sure you get the project working before you embark on extensions. It’s easy to get too ambitious at the beginning and end up with a mass of code that proves impossible to debug.
Grading
• (10’) Your interpreter should be able to present a GUI and interact with user input.
o GUI should contain the input and output interfaces shown in Figure 2. 
• (20’) Your interpreter should be able to load and edit basic programs.
o Users can add, update or delete statements through input box or LOAD button.
o The statements entered by user can be stored and displayed in the correct order.
• (50’) Your interpreter should be able to interpret basic programs correctly.
o Expression parsing (display the syntax tree, although this should be done when you store the programs);
o Expression evaluation and statement execution (display the result of print if exists);
o Runtime context maintenance (e.g., the current line to be executed, all variables and their values).
o Debug mode (break points, display program variables)
• (10’) Your interpreter should be robust and correctly handle errors in the input.
• (10’) You should finish the project with object-oriented design and implementation; your code should be clear and easy to read with appropriate comments.
 
Hints:
You could learn something from this article. But there are always other ways to achieve the same goal, and you are not restricted by the article.
 

基于 STM32F407 的环境监测与报警系统 本项目基于正点原子探索者F407开发板,集成光照、温度监测与报警功能,通过TFT-LCD以暗色科技风界面实时显示数据,并支持按键及串口设定阈值。利用HAL库驱动多个外设,实现多任务协同:光敏电阻与内部温度传感器采样结合滑动平均滤波,确保数据稳定;蜂鸣器与LED在超限情况下非阻塞报警;采用状态机管理设定模式,界面友好。代码结构清晰,适合初学者学习外设整合与综合应用开发。 阅读详情

相关推荐

【大模型】MHA,MQA,GQA及KV Cache详解

在自回归模型中(Autoregressive Models),模型会逐个生成文本的每个token,这个过程可能比较慢,因为模型一次只能生成一个token,而且每次新的预测都依赖于之前的上下文。这意味着,要预测第1000个token,你需要用到前999个token的信息,这通常涉及到对这些token的表示进行一系列矩阵乘法运算。而要预测第1001个token,你不仅需要前999个token的信息,还要加上第1000个token的信息。

酒酿小圆子呀~ 2616

C/C++Minimal Basic (or QBasic)[2023-12-29]

60 ENDFigure 1GOTO n40 PRINT T60 GOTO 3070 ENDPRINT expINPUT varGOTO nFigure 2LET =mpqtFigure 3IF THENmmaxnFigure 43. GOTO nGOTOnFigure 5Grading。

code helper 458

EtherCAT从站协议栈---- sampleappl.c 文件解析

这个源文件实际上包含该项目的入口函数main函数。 那么如何找到入口函数呢? 可以进入debug的simulator模式,选中run to main(), 当执行完启动文件startup_cm3.s后就进入了main函数(注意在main函数之前还进入了SystemInit函数), 如下图所示: 这个main函数主要架构如下: int main(void) { HW_Init(); /*PDI(过程数据接口)初始化,这里用的是MCI接.

Jiawei_Z的博客 3071

自动化脚本中如何创建自定义界面(UI)

冰狐的 UI 体系有一个容易被低估的设计取向:它没有在脚本运行时去拼装视图树,而是把界面描述固定在 XML 模板里,把事件逻辑交给 JS 处理。这种“模板在前、逻辑在后”的分工,让界面结构在编码阶段就是确定且可读的,调试时改一行 XML 就能立刻看到效果,不需要反复重启脚本去观察视图的拼装过程。

ai_coder_ai的博客 495

告别混乱!AutoSar BswM模式管理实战:手把手教你配置Rule与ActionList(附避坑指南)

本文详细解析了AutoSar BswM模式管理的实战配置,重点介绍了Rule与ActionList的高效组合方法,帮助开发者避免常见陷阱。通过具体案例演示了从基础到复杂的配置步骤,包括模式仲裁、逻辑表达式构建及ActionList优化策略,提升汽车电子系统的协调性与可靠性。

weixin_27066963的博客 260

嘉立创EDA报错:元件引脚与焊盘未对应报错解决记录

原件引脚与焊盘未对应报错解决方法,一文总结!

2303_77013775的博客 1万+

21st.dev 上手教程:12000+ React 组件库怎么用,6 步从挑样式到接进 Cursor

21st.dev 收录 12000+ 个 React + Tailwind 组件、297 套整站模板与 979 套主题。本文是手把手流程版:按页面用途找组件、用复制或 shadcn CLI 落地、接入 MCP 让 Cursor 自己取代码、用整站模板开局,附 10 张真实组件截图和 4 个常见坑。

懿轩的技术小窝 241

STM32实战开发(128):智能位移检测 - 使用STM32实现位移检测

STM32作为一款功能强大的微控制器,由于其出色的处理能力、丰富的外设接口和低功耗特点,成为实现智能位移检测系统的理想选择。未来,可以通过结合更多传感器、多种数据处理算法以及云平台技术,进一步提升系统的智能化水平,优化位移测量的精度和稳定性。本篇博客将介绍如何使用STM32微控制器实现智能位移检测系统,涉及硬件设计、传感器选择、软件开发等多个方面,提供详细的设计步骤,并给出完整的代码示例,帮助开发者快速搭建智能位移检测系统。蜂鸣器连接到STM32的GPIO端口,当位移超过设定的阈值时,蜂鸣器发出警报。

2201_76125393的博客 902

兰亭妙微ui设计公司分享移动端UI设计:手机UI动效怎样从漂亮展示走向可讨论的原型

移动端UI动效设计需超越“视觉好看”,聚焦用户理解与交互逻辑。通过卡片展开、手势响应等动效,强化页面间内容连续性,保留关键视觉线索。设计应明确动效触发条件、结束状态及中途打断处理,结合静态图层与动态原型并行展示,提升评审效率。强调组件一致性、真实内容测试与清晰任务引导,让动效成为可推敲的协作工具,而非仅作演示素材。

lanlanwork12的博客 211

连接参数详解:Connection Interval, Slave Latency, Supervision Timeout 的协同与调优实战

在低功耗蓝牙(BLE)开发与调试中,Connection Interval(连接间隔)、Slave Latency(从机延迟) 和 Supervision Timeout(监督超时) 是三个核心参数。它们不仅直接影响设备的通信性能、功耗表现和连接稳定性,更是各类技术面试与认证考试的高频考点。本文将从基础概念出发,深入剖析三者的协同机制,结合历年真题解析考点与解题思路,并通过实战案例演示调优方法,快速掌握这一核心知识点。

byte轻骑兵的技术小窝 2764

基于FPGA的时间数字转换(TDC)设计(五:基于Carry4的高精度TDC设计)

基于FPGA的时间数字转换(TDC)设计,此为第五篇:基于Carry4的高精度TDC设计。提供工程文件及MATLAB测试分析代码

sdau2005的博客 8808

BLG大战T1导致应用大规模启动

2026年11月9日,BLG对战T1赛事结束后4小时,因iOS灵动岛功能特性引发大规模应用后台启动。赛事期间用户开启灵动岛,赛后系统推送结束消息,但锁屏UI延迟4小时集中移除,触发大量客户端后台唤醒,导致登录态续期、设备指纹等服务告警。经排查,问题仅限iOS端,根源为灵动岛默认4小时后移除锁屏界面时自动唤醒应用。优化措施包括:临时扩容、推送打散(多通道串行+时间错峰)、客户端识别并保护后端请求,有效缓解压力。

weixin_42448366的博客 209

【数据同化第二期】数据同化中三大理论基础之一(最小方差估计)

【数据同化第二期】深入理解数据同化及经典案例(最小方差估计)

WW、forever的博客 1598

JS - 进阶

JavaScript的隐式类型转换遵循严格规范,核心为转原始值、数字、字符串和布尔值。对象通过Symbol.toPrimitive、toString或valueOf转换,加法运算中任一操作数为字符串则拼接,否则转数字相加;==会尝试类型转换,建议使用===。事件循环(EventLoop)中,同步代码执行后清空微任务队列(如Promise.then),再渲染界面并执行宏任务(如setTimeout)。微任务优先级高于宏任务,且可嵌套执行。async/await本质是微任务,用于简化异步编程。

D_xw_的博客 345

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

清绘AI 是什么?能力、模式、模型与适用边界

清绘AI是一站式 AI 创作平台,把生图、生视频、生音频、编辑修改、资产管理与剪辑整合在同一工作台,用于海报、电商物料、UI 概念稿、分镜脚本与短视频的批量产出。平台面向设计师、运营、产品、销售、自媒体与企业团队,网页端与手机端均可使用,提供无限画布与工作流两种创作模式。

Funkyyo的博客 97

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

Android 开发入门实践(十三):用 Intent、UiState 和 Reducer 理解 MVI 的状态更新

本文记录第141—145课对MVI架构的入门实践,通过“返回列表”功能逐步构建意图(NewsIntent)、状态(NewsUiState)与状态转换(reduce)机制。基于单向数据流,用户操作生成意图,ViewModel通过Reducer根据旧状态计算新状态,并通过StateFlow更新Compose界面。代码实现清晰分离关注点,强化了对状态管理、事件驱动与数据流的理解。

Easyhood的博客 357

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

从命令式到声明式:ArkUI 心智模型转身记

从命令式到声明式,不是一个语法的切换,而是一次思维方式的转身:从「我去把界面改了」变成「我让界面长成数据的样子」。刚开始会觉得「手脚被捆住」,但当你不再为「界面和数据对不上」而 debug 到深夜时,你会感谢这次转身。下一次写 `build()` 之前,先问自己一句:**我是在描述「长什么样」,还是在命令「怎么改」?

wdracky的专栏 314

添加xaml页面。WPF 多视图切换(UserControl 页面路由 / 视图切换模式)*

1、创建WPF App(.NET Framework / .NET) 解决方案 Test2、MainWindow 作为外壳主窗口2.1 MainWindow.xaml:定义Grid行列布局,划分【按钮菜单栏区域】+【ContentControl视图容器】2.2 MainWindow.xaml.cs:实现通用切换方法 SwitchView(UserControl view),给ContentControl赋值2.3 各个按钮点击事件里调用 SwitchView(视图实例)

zxf347085420的博客 184

兰亭妙微ui设计公司分享QT界面开发:Qt设备界面的改动,怎样在预览里看清楚

本文分享一套针对设备参数界面微调的评审思路:以具体操作任务为起点,明确观察范围,保留修改前状态进行对比,关注单位、输入、提示等元素在正常与异常状态下的呈现。强调在不同屏幕尺寸下重走任务流程,记录可复查的证据,区分观察与结论,确保设计变更真正服务于用户任务。实时预览虽便捷,但需明确其边界,最终以可验证、可追溯的方式推动协作与验收。

lanlanwork12的博客 181

Flutter学习day13--Provider实战重构套路

写 Flutter 的头几周,setState几乎能解决所有问题:数据变了,调一下,界面就刷新了。这些问题有一个共同的名字——。Provider 就是 Flutter 官方推荐的基础状态管理方案,它不引入复杂的响应式系统,只是把「状态」从组件树里拎出来,放在一个所有组件都能访问的位置,并用的机制精确通知依赖它的组件。。

qq_63223749的博客 363

自动化脚本中自定义界面(ui)之输入框

冰狐的 UI 体系用 XML 描述结构,用 JavaScript 处理逻辑。在这个体系里,输入框的控件名是edit,但它的定位需要先厘清一个继承关系:edittext,所有适用于文本控件的属性和函数,在输入框上同样成立。这意味着textsizegravity这些文本控件属性在输入框上可以直接使用,setText()和getText()也并非输入框独有。真正把输入框和普通文本控件拉开距离的,是它“可编辑”这一层。普通text只负责展示,edit负责接收用户输入。hint用于在内容为空时显示提示文字,

jcgu的专栏 248

用 AI 在 Unity 里做一款 RTS:最难的不是生成代码,而是证明它真的能玩

git@github.com:zoucdr/unity-skilled-mcp.git

邹杭特的博客 287

KMP学习day9--Ktor网络层与安全请求

做一个 KMP(Kotlin Multiplatform)项目时,最先撞上的问题是:网络请求怎么写?Flutter 有 http/Dio,iOS 有 URLSession,Android 有 OkHttp——但如果业务逻辑放在共享层(commonMain),就不能直接依赖任何一端的网络库。Ktor 正是为此而生的:它是 JetBrains 官方的 Kotlin 异步框架,其 Client 模块提供了一套。

qq_63223749的博客 200

Avalonia 设备监测实战设计|高频采样怎么接到实时曲线、热力图和 3D 视图?

设备每秒推来的采样批次和页面刷新的节奏通常不同。把每条采样直接推给 UI,会让绘制次数跟着输入速率增长。用做 Avalonia 监测页面时,可以把采集、显示窗口和视图更新拆开,再用测点 ID 把三个视图串起来。

2501_91602431的博客 70

智能体(GUI Agent / Computer-Use Agent / Action-Oriented AI)

2025–2026年,AI从“对话生成”迈向“动手执行”,指向智能体(GUI Agent)成为核心跃迁。其通过多模态理解、视觉定位与系统级操作,实现像人一样看屏、决策、点击、执行。底层依赖VLM+任务规划、坐标定位、记忆管理与环境感知。直接受益产业包括:软件工程(自动化开发)、企服SaaS(数字劳动力替代)、RPA升维、AI PC/手机端侧硬件、操作系统入口价值重估,以及推理算力与操作数据标注。未来将重塑生产力,推动“人+智能体集群”协同工作模式,实现社会全要素生产率跃升。

u013584020的博客 311
上一篇: Spatial Data and Asset
下一篇: Code development
wx____codehelp
博客等级 码龄2年 538粉丝 99原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值