תחומים - פורום חרדי מקצועי

@יגעתי-ומצאתי כתב בשגיאת פלט ב RVC WebUi שמותקן על המחשב:

אשר נמצא במסך הממשק של הRVC

לך קצת אחורה, מי פתח את הממשק הזה, ואיך?

@יוסף-בן-שמעון כתב בהאם Blazor הוא תקוות העתיד:

הבנתי גם שיכולות להיות בעיות ביצועים בשימוש ב WebAssembly

שרת Blazor לא חייב להיות WebAssembly. אם השימוש ב - Blazor הוא רק בשביל צד הלקוח, אז הקוד #C רץ בדפדפן באמצעות WebAssembly, אבל שרת Blazor רגיל לא משתמש עם WebAssembly אלא מריץ את הקוד #C בצד השרת.

@יהודי-טוב כתב בTTS ונרמול דאטה:

התמלול הזה מאוד דומה לתמלול של openAI (הגיוני שזה על מודול שלהם)

המודל של OpenAI נקרא whisper והפרויקט הנ"ל של העברית הוא גם whisper שעבר fine-tuning על הרבה נתונים בעברית.

אגב יצא לי לבדוק את whisper עם whisper.cpp (שזה זמן ריצה של whisper) והתוצאות היו ממש טובות, לסרטון אקראי של 10 דקות התמלול היה מצוין עם טעויות בודדות, אבל בגרסאות הקטנות יותר (מתחת ל - medium) התמלול היה על הפנים.

@n123456 כתב באבטחת חשבונות:

2.לגבי האימות שנהיה נפוץ היום דרך אפליקציה שמקבלים מספר. האם למשתמשי נטפרי בעלי טלפון ללא אינטרנט יש אפשרות איך שהוא לעשות את זה?

אם אתה מתכוון לאפליקציית אימות, אז הרבה פעמים מופיע ליד הברקוד לחצן שמאפשר להעתיק את הקוד הראשוני שהאתר יצר, בלי צורך לסרוק את הברקוד.

התוכנת תרגום שפורסמה כאן בנויה עם avalonia, (אם יהיה לי פנאי אני אפרסם בקרוב גרסה חדשה של התוכנה שכוללת גם שינוי עיצובי)

אם אתה רוצה לראות סתם גלריית theme שבנויה עם avalonia, תוריד את זה: (צריך להיות מחובר לחשבון GitHub)
https://github.com/kikipoulet/SukiUI/actions/runs/12388950546/artifacts/2336318341

@pcinfogmach כתב בסקיצה איך ליישם Theming ב- wpf בצורה קלה ונוחה:

אם כבר אנחנו מדברים על spinoff של wpf מה אתה אומר על uno? לא ניסיתי את זה מעניין לשמוע ממישהו שכן ניסה אם יש?

לא התנסתי ב- uno, אבל נדמה לי שזה שילוב פלטפורמות קיימות של microsoft לבסיס אחד, זה לא באמת ממשק משתמש שנכתב מאפס, יש גם את maui. אני חושב ש - avalonia מתמקדת יותר בפיתוח desktop חוצה פלטפורמות, ופחות ל - mobile (כיום יש תמיכה רחבה גם ל - mobile אבל בעבר זו לא היה יציב)

סתם ככה היה לי הרגשה של "כמעט" כשהתעסקתי עם avalonia לא באתי ללכלך אבל מסקרן אותי כמה ההרגשה הזו אישית והאם יש בה ממש.

אני כיום מפתח עבור desktop רק עם avalonia בלי מחשבה לחזור אי פעם ל wpf.

@pcinfogmach כתב בסקיצה איך ליישם Theming ב- wpf בצורה קלה ונוחה:

מכיוון שהצורך שלי היה ב-Dark Mode, יצרתי קוד שמזהה באופן אוטומטי אם המערכת מוגדרת ל-Dark Theme.
בנוסף, הוספתי כפתור שמאפשר מעבר בין Dark Mode ל-Light Mode.

אגב, על AvaloniaUI שמעת? אם לא, אני ממליץ לך בחום להגר לשם (זה מאוד קל למפתחי wpf), חוץ מזה שזה חוצה פלטפורמות ועוד המון פיצ'רים, יש שם גם dark-mode שמובנה ומזוהה אוטומטית בהתאם להגדרות המחשב.

ואגב, למי שלא אוהב לשתף קטעי קוד שלו עם GitHub, מומלץ לבטל את הסימון באפשרות: 'Allow GitHub to use my code snippets from the code editor for product improvements', בעמוד ההגדרות.

GitHub מכריזה ש - Copilot זמין כעת בחינם עבור כל המשתמשים. זה כנראה מגיע כהמשך לשדרוג Copilot והוספת המודלים החדשים OpenAI o1 ו - Gemini 1.5 Pro. המודלים שזמינים כעת בחינם הם OpenAI GPT o4 ו - Claude 3.5 Sonnet, עם מגבלה של 2000 השלמות קוד ו - 50 הודעות chat בחודש.

להמשך קריאה:
https://github.blog/changelog/2024-12-18-announcing-github-copilot-free/

@yossiz גם אני נתקל בבעיות האלו, ולפעמים אפילו התוכנה נסגרת מבלי לציין שום exception, קשה לשחזר את זה כי זה קורה רק בפרויקטים גדולים עם קוד אסינכרוני, לדוגמא יש לי Task.Run שבתוכו יש try/catch שהוא נקרא ממתודה אסינכרונית אחרת שגם היא עוטפת אותו ב - try/catch, ואז עם כל הבלגן הזה פתאום נופלת לך שגיאה במקום לא ברור. בפרויקטים קטנים זה פשוט לא קורה.

לפעמים אפילו vs מציב לי את השגיאה בפונקציה שמריצה את ה thread הראשי באתחול האפליקציה.

@dovid כתב בשימוש נכון ב-await Task.Run ב-C#:

ובCPU, צריך לעשות ממש דברים רציניים מאוד כדי שתהיה הצדקה לקפיאה.

באפליקציה קלאסית נתקלים בזה כשמריצים סינון על הרבה פריטים באמצעות תיבת חיפוש, ולפעמים ה - UI קופא לזמן קצר, במקרה הזה הפתרון להשתמש ב - Task.Run.

יש שני סיבות למה להשתמש בכלל בTask:
א. לומר לתוכנה שהיא לא צריכה הרגע לחכות לתוצאה, אלא לכשתגיע נדבר.
ב. לנצל את ריבוי המעבדים.

הייתי מגדיר את זה טיפה שונה: המטרה העיקרית של Task ו - async/await היא לא לחסום את ה - thread הראשי. המושג הכללי multi-threading נועד גם בין היתר לנצל את ריבוי המעבדים.

@dovid כתב בשימוש נכון ב-await Task.Run ב-C#:

את הפונקציה השניה הייתי משתמש בכלים המובנים יותר כיום:

לכאורה הוא השתמש בשיטה שלו כדי למנוע את טעינת יתר השורות לזכרון.

עריכה: אני לא צודק, שימוש ב - ReadLinesAsync לא יטען את שאר השורות.

@pcinfogmach כתב בשימוש נכון ב-await Task.Run ב-C#:

כמו"כ קראתי כמה פעמים על משהו שנקרא תנאי תחרות (Race Condition) כשמשתמשים ב-Multithreading - אני חייב לומר שלא בדיוק הבנתי את הנושא.

קח את הקוד הבא:

var count = 0;

void Increment()
{
    for (var i = 0; i < 1_000_000; i++)
    {
        count++;
    }
}

var task1 = Task.Run(Increment);
var task2 = Task.Run(Increment);

await Task.WhenAll([task1, task2]);

Console.WriteLine(count);

הקוד הזה מריץ במקביל שני פונקיות שמקדמות את count במיליון, אם תצפה ש count יהיה שווה לשני מליון אחרי ההרצה, אז אתה תתפלא לראות שבכל הרצה מודפס ערך שונה, ואף פעם לא שני מליון.

הסיבה לזה טמונה לדרך הפעולות של המעבד. הקוד ++count נראה פשוט אבל מורכב מכמה פעולות:
א. קריאת הערך של count
ב. חישוב הערך החדש
ג. כתיבת הערך החדש ל - count

בגלל שהפעולות מתבצעות במקביל אז כשהמעבד עובר בין ה - threadים (בתהליך שנקרא context-switch) זה גם יכול לקרות באמצע הפעולות הנ"ל, לדוגמא אחרי פעולות א' ו-ב' המעבד עובר ל - thread השני ואז התוצאה היא שאיבדנו קידום של ספרה אחת.

אם תשנה את שורה 7 לזה:

Interlocked.Increment(ref count);

או לזה:

lock(...)
{
    count++;
}

תראה שהתוצאה היא שני מליון כמצופה, וזה קורה בגלל שנעלנו את הקטע הקריטי שבו אנחנו צריכים שיהיה סינכרון בין שני ה threadים, ולא יבוצע עדכון במקביל, במילים אחרות, במקרה הזה זה מחייב שפעולות א' ב' ו-ג' יתבצעו ביחד ולא יתפרקו באמצע.

אני יודע שזה מסובך אבל ניסיתי להסביר כמה שהתאפשר לי.

@pcinfogmach כתב בשימוש נכון ב-await Task.Run ב-C#:

מהם ההדרכות לכתיבת קוד אסינכרוני ב-C# וממה יש להיזהר?

זה נושא מורכב שהרבה מסתבכים איתו ועושים טעויות, אני ממליץ לך לעבור על המסמך AsyncGuidance שהתודעתי אליו בעבר מהפורום.

@pcinfogmach כתב בDebugging על ViewModel ב-WPF:

שוב נתקלתי בבעיה זו והעצה שלך לא עזרה...

תנסה לעקוב בחלונית ה - call stack אחרי המקום בקוד שלך שבו החריג נזרק.

@pcinfogmach כתב בDebugging על ViewModel ב-WPF:

ובפרט מה בדיוק עושה מה ש@Mordechai-0 אמר Enable Just my code

האופציה הזאת מאפשרת לדבג קוד חיצוני שאינו חלק מהפרוייקט שלך, לצורך הדוגמא: אם הכנסת break point באיזשהו מקום בקוד ואתה מתקדם שורה שורה עם F10 או F11, אז אם Enable Just my code מופעל F11 לא יכנס לפונציות שהם לא בקוד שלך, אם הוא מבוטל זה יכנס גם לקוד שהוא ממקור חיצוני באמצעות דה-קומפלציה (או source link).

בקשר ל-default, זכור לי שזה השתנה בין הגרסאות של visual studio.

@pcinfogmach כתב במדריך: איך לייצר לוקליזציה ב-wpf בצורה פשוטה וקלילה:

כשאתה בונה כמה פרוייקטים במקביל הפעולות המכניות הזוטרות האלה שחוזרים על עצמם שוב ושוב מתחילים להציק לך מאוד

הפתרון הוא לכתוב ספרייה משותפת שמאגדת את כל הבסיס לפרויקטים שלך, לדוגמא: classים בסיסיים של ViewModel (או reference לספריית MVVM כלשהיא), Localization, Theme, DI וכל מה שאתה משתמש

בכל פרויקט חדש אתה פשוט מוסיף reference לספרייה המשותפת (ואולי עוד כמה שורות קוד), וככה חסכת הרבה זמן בהקמה של הפרויקט

@pcinfogmach לא עברתי על כל הקוד, אבל זה נראה מלמעלה שאי אפשר לשנות את השפה בזמן הריצה של האפליקציה, תנסה ליישם משהו שמאפשר לשנות את השפה בצורה דינאמית, מבלי להפעיל מחדש

זה ככל הנראה קשור לקנה מידה של המסך, כדי לאמת את זה אתה יכול לשנות בהגדרות מסך את הקנה מידה ל - 100% ולבדוק האם אחרי זה החיתוך מתבצע טוב.

הצלחתי בסוף להגדיר את rollup, והתוצאה נראית הרבה יותר טוב.
זה דוגמא לקובץ סופי (שמורכב משני קבצי ts) עם- rollup:

function showMessage(message) {
  alert(message);
}

showMessage("hello");

וככה הוא נראה עם - webpack:

/******/ (function() { // webpackBootstrap
/******/ 	"use strict";
/******/ 	var __webpack_modules__ = ({

/***/ 420:
/***/ (function(__unused_webpack_module, exports) {



exports.__esModule = true;
exports.showMessage = showMessage;
function showMessage(message) {
  alert(message);
}

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};


var _dialogs = __webpack_require__(420);
(0, _dialogs.showMessage)("hello");
/******/ })()
;

זה הקונפיגורציה המינימאלית של rollup:

import typescript from '@rollup/plugin-typescript';
import babel from '@rollup/plugin-babel';

export default {
    input: 'src/index.ts',
    output: {
        file: 'dist/drop-word-script.js'
    },
    plugins: [
        typescript(),
        babel({
            babelHelpers: 'bundled',
            presets: [
                ['@babel/preset-env']
            ],
            extensions: ['.js', '.ts']
        })
    ],
};